@portabletext/plugin-input-rule 1.0.22 → 1.0.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/plugin-input-rule",
-  "version": "1.0.22",
+  "version": "1.0.24",
   "description": "Easily configure input rules in the Portable Text Editor",
   "keywords": [
     "portabletext",
@@ -30,12 +30,11 @@
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "dependencies": {
     "@xstate/react": "^6.0.0",
-    "react-compiler-runtime": "1.0.0",
+    "react-compiler-runtime": "^1.0.0",
     "xstate": "^5.24.0"
   },
   "devDependencies": {
@@ -45,20 +44,20 @@
     "@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-formatter-gha": "^1.6.0",
-    "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",
-    "@portabletext/schema": "2.0.0",
-    "racejar": "2.0.0"
+    "@portabletext/editor": "3.3.4",
+    "@portabletext/schema": "2.0.1",
+    "racejar": "2.0.1"
   },
   "peerDependencies": {
-    "@portabletext/editor": "^3.3.2",
+    "@portabletext/editor": "^3.3.4",
     "react": "^18.3 || ^19"
   },
   "engines": {

package/src/edge-cases.feature

@@ -1,207 +0,0 @@
-Feature: Edge Cases
-
-  Background:
-    Given a global keymap
-
-  Scenario Outline: Longer Transform
-    Given the text <text>
-    When <inserted text> is inserted
-    And "new" is typed
-    Then the text is <new text>
-
-    Examples:
-      | text       | inserted text | new text            |
-      | ""         | "."           | "...new"            |
-      | "foo"      | "."           | "foo...new"         |
-      | ""         | "foo."        | "foo...new"         |
-      | "foo."     | "."           | "foo....new"        |
-      | ""         | "foo.bar."    | "foo...bar...new"   |
-      | "foo.bar." | "baz."        | "foo.bar.baz...new" |
-
-  Scenario Outline: End String Rule
-    Given the text <text>
-    When <inserted text> is inserted
-    And "new" is typed
-    Then the text is <new text>
-
-    Examples:
-      | text         | inserted text | new text            |
-      | "-"          | ">"           | "→new"              |
-      | ""           | "->"          | "→new"              |
-      | "foo"        | "->"          | "foo→new"           |
-      | ""           | "foo->"       | "foo→new"           |
-      | "foo-"       | ">bar"        | "foo->barnew"       |
-      | ""           | "foo->bar->"  | "foo->bar→new"      |
-      | "foo->bar->" | "baz->"       | "foo->bar->baz→new" |
-
-  Scenario Outline: Non-Global Rule
-    Given the text <text>
-    When <inserted text> is inserted
-    And "new" is typed
-    Then the text is <new text>
-
-    Examples:
-      | text           | inserted text  | new text              |
-      | "(c"           | ")"            | "©new"                |
-      | ""             | "(c)"          | "©new"                |
-      | "foo"          | "(c)"          | "foo©new"             |
-      | ""             | "foo(c)"       | "foo©new"             |
-      | "foo(c"        | ")bar"         | "foo©barnew"          |
-      | ""             | "foo(c)bar(c)" | "foo©bar©new"         |
-      | "foo(c)bar(c)" | "baz(c)"       | "foo(c)bar(c)baz©new" |
-
-  Scenario Outline: Writing after Multiple Groups Rule
-    Given the text <text>
-    When <inserted text> is inserted
-    And "new" is typed
-    Then the text is <new text>
-
-    Examples:
-      | text    | inserted text | new text       |
-      | ""      | "xfooy"       | "zfooznew"     |
-      | "xfoo"  | "y"           | "zfooznew"     |
-      | "xfooy" | "z"           | "xfooyznew"    |
-      | ""      | "xfyxoy"      | "zfzzoznew"    |
-      | ""      | "xfyxoyxoy"   | "zfzzozzoznew" |
-
-  Scenario Outline: Replacing 'a' and 'c'
-    Given the text <text>
-    When <inserted text> is inserted
-    And "new" is typed
-    Then the text is <new text>
-
-    Examples:
-      | text | inserted text | new text |
-      | ""   | "ABC"         | "CBAnew" |
-      | "AB" | "C"           | "CBAnew" |
-
-  Scenario Outline: Undoing Multiple Groups Rule
-    Given the text <text>
-    When <inserted text> is inserted
-    Then the text is <before undo>
-    When undo is performed
-    Then the text is <after undo>
-
-    Examples:
-      | text    | inserted text | before undo | after undo  |
-      | ""      | "xfooy"       | "zfooz"     | "xfooy"     |
-      | "xfoo"  | "y"           | "zfooz"     | "xfooy"     |
-      | "xfooy" | "z"           | "xfooyz"    | "xfooy"     |
-      | ""      | "xfyxoy"      | "zfzzoz"    | "xfyxoy"    |
-      | ""      | "xfyxoyxoy"   | "zfzzozzoz" | "xfyxoyxoy" |
-
-  Scenario Outline: Preserving inline objects
-    Given the text <text>
-    When <inserted text> is inserted
-    And "new" is typed
-    Then the text is <new text>
-
-    Examples:
-      | text                                | inserted text | new text                                |
-      | "(,{stock-ticker},c"                | ")"           | "(,{stock-ticker},c)new"                |
-      | "-,{stock-ticker},"                 | ">"           | "-,{stock-ticker},>new"                 |
-      | ",{stock-ticker},-,{stock-ticker}," | ">"           | ",{stock-ticker},-,{stock-ticker},>new" |
-      | ",{stock-ticker},-"                 | ">"           | ",{stock-ticker},→new"                  |
-
-  Scenario: Preserving adjoining inline object and placing caret correctly
-    Given the text "(c,{stock-ticker},"
-    When the caret is put after "c"
-    And ")new" is typed
-    Then the text is "©new,{stock-ticker},"
-
-  Scenario: Preserving adjoining inline object and placing caret correctly
-    Given the text "#,{stock-ticker},"
-    When the caret is put after "#"
-    And " new" is typed
-    Then the text is "new,{stock-ticker},"
-
-  Scenario Outline: H1 rule
-    Given the text <text>
-    When the caret is put <position>
-    And <key> is pressed
-    And "# " is inserted
-    And "new" is typed
-    Then the text is <new text>
-
-    Examples:
-      | text                  | position    | key           | new text                   |
-      # Pressing Shift is a noop. It only exists so we can press Backspace in
-      # subsequent Scenarios to position to caret at the edge of the inline
-      # object.
-      | ""                    | after ""    | "{Shift}"     | "new"                      |
-      | "foo"                 | after "foo" | "{Shift}"     | "foo# new"                 |
-      | ",{stock-ticker},foo" | after "foo" | "{Shift}"     | ",{stock-ticker},foo# new" |
-      # This is an edge case we have to live with. There's no way of knowing
-      # that the inline object before the caret should prevent the rule from
-      # running.
-      | ",{stock-ticker},f"   | after "f"   | "{Backspace}" | "new,{stock-ticker},"      |
-      | "f,{stock-ticker},"   | after "f"   | "{Backspace}" | "new,{stock-ticker},"      |
-
-  Scenario Outline: Better H2 rule
-    Given the text <text>
-    When the caret is put <position>
-    And <key> is pressed
-    And "## " is inserted
-    And "new" is typed
-    Then the text is <new text>
-
-    Examples:
-      | text                  | position    | key           | new text                    |
-      # Pressing Shift is a noop. It only exists so we can press Backspace in
-      # subsequent Scenarios to position to caret at the edge of the inline
-      # object.
-      | ""                    | after ""    | "{Shift}"     | "new"                       |
-      | "foo"                 | after "foo" | "{Shift}"     | "foo## new"                 |
-      | ",{stock-ticker},foo" | after "foo" | "{Shift}"     | ",{stock-ticker},foo## new" |
-      | ",{stock-ticker},f"   | after "f"   | "{Backspace}" | ",{stock-ticker},## new"    |
-      | "f,{stock-ticker},"   | after "f"   | "{Backspace}" | "new,{stock-ticker},"       |
-
-  Scenario Outline: Unmatched Groups Rule
-    Given the text <text>
-    When the caret is put <position>
-    And <inserted text> is inserted
-    And "new" is typed
-    Then the text is <new text>
-
-    Examples:
-      | text | position | inserted text | new text    |
-      | ""   | after "" | "---"         | "<hr />new" |
-
-  Scenario Outline: Expanded selection
-    Given the text <text>
-    When <selection> is selected
-    And <inserted text> is inserted
-    And "new" is typed
-    Then the text is <new text>
-
-    Examples:
-      | text        | selection | inserted text | new text  |
-      | "(foo"      | "foo"     | "c)"          | "©new"    |
-      | "(foo"      | "oo"      | "c)"          | "(fc)new" |
-      | "(foo"      | "(foo"    | "c)"          | "c)new"   |
-      | "(coo\|bar" | "ooba"    | ")"           | "©newr"   |
-
-  Scenario Outline: Undo after transform on expanded selection
-    Given the text <text>
-    When <selection> is selected
-    And <inserted text> is inserted
-    Then the text is <before undo>
-    When undo is performed
-    Then the text is <after undo>
-
-    Examples:
-      | text  | selection | inserted text | before undo | after undo |
-      | "(cf" | "f"       | ")"           | "©"         | "(c)"      |
-
-  Scenario: Consecutive undo after selection change
-    Given the text ""
-    When "->" is typed
-    And undo is performed
-    And "{ArrowLeft}" is pressed
-    And undo is performed
-    Then the text is "-"
-
-  Scenario Outline: Multiple overlapping matches in one insertion
-    Given the text ""
-    When "1*2*3" is inserted
-    Then the text is "1×2×3"

package/src/edge-cases.test.tsx

@@ -1,96 +0,0 @@
-import {getPreviousInlineObject} from '@portabletext/editor/selectors'
-import {parameterTypes} from '@portabletext/editor/test'
-import {
-  createTestEditor,
-  stepDefinitions,
-  type Context,
-} from '@portabletext/editor/test/vitest'
-import {defineSchema} from '@portabletext/schema'
-import {Before} from 'racejar'
-import {Feature} from 'racejar/vitest'
-import edgeCasesFeature from './edge-cases.feature?raw'
-import {InputRulePlugin} from './plugin.input-rule'
-import {defineTextTransformRule} from './text-transform-rule'
-
-const longerTransformRule = defineTextTransformRule({
-  on: /\./,
-  transform: () => '...',
-})
-
-const endStringRule = defineTextTransformRule({
-  on: /->$/,
-  transform: () => '→',
-})
-
-const nonGlobalRule = defineTextTransformRule({
-  on: /\(c\)/,
-  transform: () => '©',
-})
-
-const multipleGroupsRule = defineTextTransformRule({
-  on: /(x)[fo]+(y)/,
-  transform: () => 'z',
-})
-
-const replaceAandCRule = defineTextTransformRule({
-  on: /(A).*(C)/,
-  transform: ({location}) => {
-    return location.text === 'A' ? 'C' : 'A'
-  },
-})
-
-const h1Rule = defineTextTransformRule({
-  on: /^(# )/,
-  transform: () => '',
-})
-
-const betterH2Rule = defineTextTransformRule({
-  on: /^(## )/,
-  guard: ({snapshot}) => {
-    return !getPreviousInlineObject(snapshot)
-  },
-  transform: () => '',
-})
-
-const unmatchedGroupsRule = defineTextTransformRule({
-  on: /^(---)|^(—-)|^(___)|^(\*\*\*)/,
-  transform: () => '<hr />',
-})
-
-const multiplicationRule = defineTextTransformRule({
-  on: /\d+\s?([*x])\s?\d+/,
-  transform: () => '×',
-})
-
-Feature({
-  hooks: [
-    Before(async (context: Context) => {
-      const {editor, locator} = await createTestEditor({
-        children: (
-          <>
-            <InputRulePlugin rules={[longerTransformRule]} />
-            <InputRulePlugin rules={[endStringRule]} />
-            <InputRulePlugin rules={[nonGlobalRule]} />
-            <InputRulePlugin rules={[multipleGroupsRule]} />
-            <InputRulePlugin rules={[h1Rule]} />
-            <InputRulePlugin rules={[betterH2Rule]} />
-            <InputRulePlugin rules={[replaceAandCRule]} />
-            <InputRulePlugin rules={[unmatchedGroupsRule]} />
-            <InputRulePlugin rules={[multiplicationRule]} />
-          </>
-        ),
-        schemaDefinition: defineSchema({
-          decorators: [{name: 'strong'}],
-          annotations: [{name: 'link'}],
-          inlineObjects: [{name: 'stock-ticker'}],
-        }),
-      })
-
-      context.locator = locator
-      context.editor = editor
-    }),
-  ],
-  featureText: edgeCasesFeature,
-  stepDefinitions,
-  parameterTypes,
-})

package/src/emoji-picker-rules.feature

@@ -1,27 +0,0 @@
-Feature: Emoji Picker Rules
-
-  Scenario: Trigger Rule
-    Given the text ""
-    When ":" is typed
-    Then the keyword is ""
-
-  Scenario: Partial Keyword Rule
-    Given the text ""
-    When ":jo" is typed
-    Then the keyword is "jo"
-
-  Scenario: Keyword Rule
-    Given the text ""
-    When ":joy:" is typed
-    Then the keyword is "joy"
-
-  Scenario Outline: Consecutive keywords
-    Given the text ":joy:"
-    When <text> is typed
-    Then the keyword is <keyword>
-
-    Examples:
-      | text    | keyword |
-      | ":"     | ""      |
-      | ":cat"  | "cat"   |
-      | ":cat:" | "cat"   |

package/src/emoji-picker-rules.test.tsx

@@ -1,124 +0,0 @@
-import {useEditor} from '@portabletext/editor'
-import {defineBehavior, effect, raise} from '@portabletext/editor/behaviors'
-import {parameterTypes} from '@portabletext/editor/test'
-import {
-  createTestEditor,
-  stepDefinitions,
-  type Context,
-} from '@portabletext/editor/test/vitest'
-import {defineSchema} from '@portabletext/schema'
-import {Before, Then} from 'racejar'
-import {Feature} from 'racejar/vitest'
-import {useEffect, useState} from 'react'
-import {expect, vi} from 'vitest'
-import {page, type Locator} from 'vitest/browser'
-import emojiPickerRulesFeature from './emoji-picker-rules.feature?raw'
-import {defineInputRule} from './input-rule'
-import {defineInputRuleBehavior} from './plugin.input-rule'
-
-const triggerRule = defineInputRule({
-  on: /:/,
-  actions: [
-    () => [
-      raise({
-        type: 'custom.keyword found',
-        keyword: '',
-      }),
-    ],
-  ],
-})
-const partialKeywordRule = defineInputRule({
-  on: /:[a-zA-Z-_0-9]+/,
-  guard: ({event}) => {
-    const lastMatch = event.matches.at(-1)
-
-    if (!lastMatch) {
-      return false
-    }
-
-    return {keyword: lastMatch.text.slice(1)}
-  },
-  actions: [(_, {keyword}) => [raise({type: 'custom.keyword found', keyword})]],
-})
-const keywordRule = defineInputRule({
-  on: /:[a-zA-Z-_0-9]+:/,
-  guard: ({event}) => {
-    const lastMatch = event.matches.at(-1)
-
-    if (!lastMatch) {
-      return false
-    }
-
-    return {keyword: lastMatch.text.slice(1, -1)}
-  },
-  actions: [(_, {keyword}) => [raise({type: 'custom.keyword found', keyword})]],
-})
-
-function EmojiPickerRulesPlugin() {
-  const editor = useEditor()
-  const [keyword, setKeyword] = useState('')
-
-  useEffect(() => {
-    const unregisterBehaviors = [
-      editor.registerBehavior({
-        behavior: defineInputRuleBehavior({
-          rules: [keywordRule, partialKeywordRule, triggerRule],
-        }),
-      }),
-      editor.registerBehavior({
-        behavior: defineBehavior<{keyword: string}>({
-          on: 'custom.keyword found',
-          actions: [
-            ({event}) => [
-              effect(() => {
-                setKeyword(event.keyword)
-              }),
-            ],
-          ],
-        }),
-      }),
-    ]
-
-    return () => {
-      for (const unregister of unregisterBehaviors) {
-        unregister()
-      }
-    }
-  }, [])
-
-  return <div data-testid="keyword">{keyword}</div>
-}
-
-Feature({
-  hooks: [
-    Before(async (context: Context & {keywordLocator: Locator}) => {
-      const {editor, locator} = await createTestEditor({
-        children: <EmojiPickerRulesPlugin />,
-        schemaDefinition: defineSchema({
-          decorators: [{name: 'strong'}],
-          annotations: [{name: 'link'}],
-          inlineObjects: [{name: 'stock-ticker'}],
-        }),
-      })
-
-      context.locator = locator
-      context.editor = editor
-      context.keywordLocator = page.getByTestId('keyword')
-
-      await vi.waitFor(() =>
-        expect.element(context.keywordLocator).toBeInTheDocument(),
-      )
-    }),
-  ],
-  featureText: emojiPickerRulesFeature,
-  stepDefinitions: [
-    ...stepDefinitions,
-    Then(
-      'the keyword is {string}',
-      (context: Context & {keywordLocator: Locator}, keyword: string) => {
-        expect(context.keywordLocator.element().textContent).toEqual(keyword)
-      },
-    ),
-  ],
-  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,3 +0,0 @@
-export * from './input-rule'
-export * from './plugin.input-rule'
-export * from './text-transform-rule'

package/src/input-rule-match-location.ts

@@ -1,123 +0,0 @@
-import type {
-  BlockOffset,
-  BlockPath,
-  EditorSelection,
-  EditorSnapshot,
-} from '@portabletext/editor'
-import {
-  getNextInlineObjects,
-  getPreviousInlineObjects,
-} from '@portabletext/editor/selectors'
-import {blockOffsetToSpanSelectionPoint} from '@portabletext/editor/utils'
-
-export type InputRuleMatchLocation = {
-  /**
-   * The matched text
-   */
-  text: string
-  /**
-   * Estimated selection of where in the original text the match is located.
-   * The selection is estimated since the match is found in the text after
-   * insertion.
-   */
-  selection: NonNullable<EditorSelection>
-  /**
-   * Block offsets of the match in the text after the insertion
-   */
-  targetOffsets: {
-    anchor: BlockOffset
-    focus: BlockOffset
-    backward: boolean
-  }
-}
-
-export function getInputRuleMatchLocation({
-  match,
-  adjustIndexBy,
-  snapshot,
-  focusBlock,
-  originalTextBefore,
-}: {
-  match: [string, number, number]
-  adjustIndexBy: number
-  snapshot: EditorSnapshot
-  focusBlock: {
-    path: BlockPath
-  }
-  originalTextBefore: string
-}): InputRuleMatchLocation | undefined {
-  const [text, start, end] = match
-  const adjustedIndex = start + adjustIndexBy
-
-  const targetOffsets = {
-    anchor: {
-      path: focusBlock.path,
-      offset: adjustedIndex,
-    },
-    focus: {
-      path: focusBlock.path,
-      offset: adjustedIndex + end - start,
-    },
-    backward: false,
-  }
-  const normalizedOffsets = {
-    anchor: {
-      path: focusBlock.path,
-      offset: Math.min(targetOffsets.anchor.offset, originalTextBefore.length),
-    },
-    focus: {
-      path: focusBlock.path,
-      offset: Math.min(targetOffsets.focus.offset, originalTextBefore.length),
-    },
-    backward: false,
-  }
-
-  const anchorBackwards = blockOffsetToSpanSelectionPoint({
-    context: snapshot.context,
-    blockOffset: normalizedOffsets.anchor,
-    direction: 'backward',
-  })
-  const focusForwards = blockOffsetToSpanSelectionPoint({
-    context: snapshot.context,
-    blockOffset: normalizedOffsets.focus,
-    direction: 'forward',
-  })
-
-  if (!anchorBackwards || !focusForwards) {
-    return undefined
-  }
-
-  const selection = {
-    anchor: anchorBackwards,
-    focus: focusForwards,
-  }
-
-  const inlineObjectsAfterMatch = getNextInlineObjects({
-    ...snapshot,
-    context: {
-      ...snapshot.context,
-      selection: {
-        anchor: selection.anchor,
-        focus: selection.anchor,
-      },
-    },
-  })
-  const inlineObjectsBefore = getPreviousInlineObjects(snapshot)
-
-  if (
-    inlineObjectsAfterMatch.some((inlineObjectAfter) =>
-      inlineObjectsBefore.some(
-        (inlineObjectBefore) =>
-          inlineObjectAfter.node._key === inlineObjectBefore.node._key,
-      ),
-    )
-  ) {
-    return undefined
-  }
-
-  return {
-    text,
-    selection,
-    targetOffsets,
-  }
-}

package/src/input-rule.ts

@@ -1,66 +0,0 @@
-import type {BlockPath, PortableTextBlock} from '@portabletext/editor'
-import type {
-  BehaviorActionSet,
-  BehaviorGuard,
-} from '@portabletext/editor/behaviors'
-import type {InputRuleMatchLocation} from './input-rule-match-location'
-
-/**
- * Match found in the text after the insertion
- * @alpha
- */
-export type InputRuleMatch = InputRuleMatchLocation & {
-  groupMatches: Array<InputRuleMatchLocation>
-}
-
-/**
- * @alpha
- */
-export type InputRuleEvent = {
-  type: 'custom.input rule'
-  /**
-   * Matches found by the input rule
-   */
-  matches: Array<InputRuleMatch>
-  /**
-   * The text before the insertion
-   */
-  textBefore: string
-  /**
-   * The text is destined to be inserted
-   */
-  textInserted: string
-  /**
-   * The block where the insertion takes place
-   */
-  focusBlock: {
-    path: BlockPath
-    node: PortableTextBlock
-  }
-}
-
-/**
- * @alpha
- */
-export type InputRuleGuard<TGuardResponse = true> = BehaviorGuard<
-  InputRuleEvent,
-  TGuardResponse
->
-
-/**
- * @alpha
- */
-export type InputRule<TGuardResponse = true> = {
-  on: RegExp
-  guard?: InputRuleGuard<TGuardResponse>
-  actions: Array<BehaviorActionSet<InputRuleEvent, TGuardResponse>>
-}
-
-/**
- * @alpha
- */
-export function defineInputRule<TGuardResponse = true>(
-  config: InputRule<TGuardResponse>,
-): InputRule<TGuardResponse> {
-  return config
-}

package/src/plugin.input-rule.tsx

@@ -1,433 +0,0 @@
-import {useEditor, type BlockOffset, type Editor} from '@portabletext/editor'
-import {
-  defineBehavior,
-  effect,
-  forward,
-  raise,
-  type BehaviorAction,
-} from '@portabletext/editor/behaviors'
-import {
-  getBlockOffsets,
-  getBlockTextBefore,
-  getFocusBlock,
-} from '@portabletext/editor/selectors'
-import {isSelectionCollapsed} from '@portabletext/editor/utils'
-import {useActorRef} from '@xstate/react'
-import {
-  fromCallback,
-  setup,
-  type AnyEventObject,
-  type CallbackLogicFunction,
-} from 'xstate'
-import type {InputRule, InputRuleMatch} from './input-rule'
-import {getInputRuleMatchLocation} from './input-rule-match-location'
-
-/**
- * @alpha
- */
-export function defineInputRuleBehavior(config: {
-  rules: Array<InputRule<any>>
-  onApply?: ({
-    endOffsets,
-  }: {
-    endOffsets: {start: BlockOffset; end: BlockOffset} | undefined
-  }) => void
-}) {
-  return defineBehavior({
-    on: 'insert.text',
-    guard: ({snapshot, event, dom}) => {
-      if (
-        !snapshot.context.selection ||
-        !isSelectionCollapsed(snapshot.context.selection)
-      ) {
-        return false
-      }
-
-      const focusBlock = getFocusBlock(snapshot)
-
-      if (!focusBlock) {
-        return false
-      }
-
-      const originalTextBefore = getBlockTextBefore(snapshot)
-      let textBefore = originalTextBefore
-      const originalNewText = textBefore + event.text
-      let newText = originalNewText
-
-      const foundMatches: Array<InputRuleMatch['groupMatches'][number]> = []
-      const foundActions: Array<BehaviorAction> = []
-
-      for (const rule of config.rules) {
-        const matcher = new RegExp(rule.on.source, 'gd')
-
-        while (true) {
-          // Find matches in the text after the insertion
-          const ruleMatches = [...newText.matchAll(matcher)].flatMap(
-            (regExpMatch) => {
-              if (regExpMatch.indices === undefined) {
-                return []
-              }
-
-              const match = regExpMatch.indices.at(0)
-
-              if (!match) {
-                return []
-              }
-
-              const matchLocation = getInputRuleMatchLocation({
-                match: [regExpMatch.at(0) ?? '', ...match],
-                adjustIndexBy: originalNewText.length - newText.length,
-                snapshot,
-                focusBlock,
-                originalTextBefore,
-              })
-
-              if (!matchLocation) {
-                return []
-              }
-
-              const existsInTextBefore =
-                matchLocation.targetOffsets.focus.offset <=
-                originalTextBefore.length
-
-              // Ignore if this match occurs in the text before the insertion
-              if (existsInTextBefore) {
-                return []
-              }
-
-              const alreadyFound = foundMatches.some(
-                (foundMatch) =>
-                  foundMatch.targetOffsets.anchor.offset ===
-                  matchLocation.targetOffsets.anchor.offset,
-              )
-
-              // Ignore if this match has already been found
-              if (alreadyFound) {
-                return []
-              }
-
-              const groupMatches =
-                regExpMatch.indices.length > 1
-                  ? regExpMatch.indices
-                      .slice(1)
-                      .filter((indices) => indices !== undefined)
-                  : []
-
-              const ruleMatch = {
-                text: matchLocation.text,
-                selection: matchLocation.selection,
-                targetOffsets: matchLocation.targetOffsets,
-                groupMatches: groupMatches.flatMap((match, index) => {
-                  const text = regExpMatch.at(index + 1) ?? ''
-                  const groupMatchLocation = getInputRuleMatchLocation({
-                    match: [text, ...match],
-                    adjustIndexBy: originalNewText.length - newText.length,
-                    snapshot,
-                    focusBlock,
-                    originalTextBefore,
-                  })
-
-                  if (!groupMatchLocation) {
-                    return []
-                  }
-
-                  return groupMatchLocation
-                }),
-              }
-
-              return [ruleMatch]
-            },
-          )
-
-          if (ruleMatches.length > 0) {
-            const guardResult =
-              rule.guard?.({
-                snapshot,
-                event: {
-                  type: 'custom.input rule',
-                  matches: ruleMatches,
-                  focusBlock,
-                  textBefore: originalTextBefore,
-                  textInserted: event.text,
-                },
-                dom,
-              }) ?? true
-
-            if (!guardResult) {
-              break
-            }
-
-            const actionSets = rule.actions.map((action) =>
-              action(
-                {
-                  snapshot,
-                  event: {
-                    type: 'custom.input rule',
-                    matches: ruleMatches,
-                    focusBlock,
-                    textBefore: originalTextBefore,
-                    textInserted: event.text,
-                  },
-                  dom,
-                },
-                guardResult,
-              ),
-            )
-
-            for (const actionSet of actionSets) {
-              for (const action of actionSet) {
-                foundActions.push(action)
-              }
-            }
-
-            const matches = ruleMatches.flatMap((match) =>
-              match.groupMatches.length === 0 ? [match] : match.groupMatches,
-            )
-
-            for (const match of matches) {
-              // Remember each match and adjust `textBefore` and `newText` so
-              // no subsequent matches can overlap with this one
-              foundMatches.push(match)
-              textBefore = newText.slice(
-                0,
-                match.targetOffsets.focus.offset ?? 0,
-              )
-              newText = originalNewText.slice(
-                match.targetOffsets.focus.offset ?? 0,
-              )
-            }
-          } else {
-            // If no match was found, break out of the loop to try the next
-            // rule
-            break
-          }
-        }
-      }
-
-      if (foundActions.length === 0) {
-        return false
-      }
-
-      return {actions: foundActions}
-    },
-    actions: [
-      ({event}) => [forward(event)],
-      (_, {actions}) => actions,
-      ({snapshot}) => [
-        effect(() => {
-          const blockOffsets = getBlockOffsets(snapshot)
-
-          config.onApply?.({endOffsets: blockOffsets})
-        }),
-      ],
-    ],
-  })
-}
-
-type InputRulePluginProps = {
-  rules: Array<InputRule<any>>
-}
-
-/**
- * Turn an array of `InputRule`s into a Behavior that can be used to apply the
- * rules to the editor.
- *
- * The plugin handles undo/redo out of the box including smart undo with
- * Backspace.
- *
- * @example
- * ```tsx
- * <InputRulePlugin rules={smartQuotesRules} />
- * ```
- *
- * @alpha
- */
-export function InputRulePlugin(props: InputRulePluginProps) {
-  const editor = useEditor()
-
-  useActorRef(inputRuleMachine, {
-    input: {editor, rules: props.rules},
-  })
-
-  return null
-}
-
-type InputRuleMachineEvent =
-  | {
-      type: 'input rule raised'
-      endOffsets: {start: BlockOffset; end: BlockOffset} | undefined
-    }
-  | {type: 'history.undo raised'}
-  | {
-      type: 'selection changed'
-      blockOffsets: {start: BlockOffset; end: BlockOffset} | undefined
-    }
-
-const inputRuleListenerCallback: CallbackLogicFunction<
-  AnyEventObject,
-  InputRuleMachineEvent,
-  {
-    editor: Editor
-    rules: Array<InputRule>
-  }
-> = ({input, sendBack}) => {
-  const unregister = input.editor.registerBehavior({
-    behavior: defineInputRuleBehavior({
-      rules: input.rules,
-      onApply: ({endOffsets}) => {
-        sendBack({type: 'input rule raised', endOffsets})
-      },
-    }),
-  })
-
-  return () => {
-    unregister()
-  }
-}
-
-const deleteBackwardListenerCallback: CallbackLogicFunction<
-  AnyEventObject,
-  InputRuleMachineEvent,
-  {editor: Editor}
-> = ({input, sendBack}) => {
-  return input.editor.registerBehavior({
-    behavior: defineBehavior({
-      on: 'delete.backward',
-      actions: [
-        () => [
-          raise({type: 'history.undo'}),
-          effect(() => {
-            sendBack({type: 'history.undo raised'})
-          }),
-        ],
-      ],
-    }),
-  })
-}
-
-const selectionListenerCallback: CallbackLogicFunction<
-  AnyEventObject,
-  InputRuleMachineEvent,
-  {editor: Editor}
-> = ({sendBack, input}) => {
-  const unregister = input.editor.registerBehavior({
-    behavior: defineBehavior({
-      on: 'select',
-      guard: ({snapshot, event}) => {
-        const blockOffsets = getBlockOffsets({
-          ...snapshot,
-          context: {
-            ...snapshot.context,
-            selection: event.at,
-          },
-        })
-
-        return {blockOffsets}
-      },
-      actions: [
-        ({event}, {blockOffsets}) => [
-          effect(() => {
-            sendBack({type: 'selection changed', blockOffsets})
-          }),
-          forward(event),
-        ],
-      ],
-    }),
-  })
-
-  return unregister
-}
-
-const inputRuleSetup = setup({
-  types: {
-    context: {} as {
-      editor: Editor
-      rules: Array<InputRule>
-      endOffsets: {start: BlockOffset; end: BlockOffset} | undefined
-    },
-    input: {} as {
-      editor: Editor
-      rules: Array<InputRule>
-    },
-    events: {} as InputRuleMachineEvent,
-  },
-  actors: {
-    'delete.backward listener': fromCallback(deleteBackwardListenerCallback),
-    'input rule listener': fromCallback(inputRuleListenerCallback),
-    'selection listener': fromCallback(selectionListenerCallback),
-  },
-  guards: {
-    'block offset changed': ({context, event}) => {
-      if (event.type !== 'selection changed') {
-        return false
-      }
-
-      if (!event.blockOffsets || !context.endOffsets) {
-        return true
-      }
-
-      const startChanged =
-        context.endOffsets.start.path[0]._key !==
-          event.blockOffsets.start.path[0]._key ||
-        context.endOffsets.start.offset !== event.blockOffsets.start.offset
-      const endChanged =
-        context.endOffsets.end.path[0]._key !==
-          event.blockOffsets.end.path[0]._key ||
-        context.endOffsets.end.offset !== event.blockOffsets.end.offset
-
-      return startChanged || endChanged
-    },
-  },
-})
-
-const assignEndOffsets = inputRuleSetup.assign({
-  endOffsets: ({context, event}) =>
-    event.type === 'input rule raised' ? event.endOffsets : context.endOffsets,
-})
-
-const inputRuleMachine = inputRuleSetup.createMachine({
-  id: 'input rule',
-  context: ({input}) => ({
-    editor: input.editor,
-    rules: input.rules,
-    endOffsets: undefined,
-  }),
-  initial: 'idle',
-  invoke: {
-    src: 'input rule listener',
-    input: ({context}) => ({
-      editor: context.editor,
-      rules: context.rules,
-    }),
-  },
-  on: {
-    'input rule raised': {
-      target: '.input rule applied',
-      actions: assignEndOffsets,
-    },
-  },
-  states: {
-    'idle': {},
-    'input rule applied': {
-      invoke: [
-        {
-          src: 'delete.backward listener',
-          input: ({context}) => ({editor: context.editor}),
-        },
-        {
-          src: 'selection listener',
-          input: ({context}) => ({editor: context.editor}),
-        },
-      ],
-      on: {
-        'selection changed': {
-          target: 'idle',
-          guard: 'block offset changed',
-        },
-        'history.undo raised': {
-          target: 'idle',
-        },
-      },
-    },
-  },
-})

package/src/rule.stock-ticker.feature

@@ -1,12 +0,0 @@
-Feature: Stock Ticker Rule
-
-  Scenario Outline: Transforms plain text into stock ticker
-    Given the text <text>
-    When <inserted text> is inserted
-    And "{ArrowRight}" is pressed
-    And "new" is typed
-    Then the text is <new text>
-
-    Examples:
-      | text | inserted text | new text              |
-      | ""   | "{AAPL}"      | ",{stock-ticker},new" |

package/src/rule.stock-ticker.test.tsx

@@ -1,46 +0,0 @@
-import {parameterTypes} from '@portabletext/editor/test'
-import {
-  createTestEditor,
-  stepDefinitions,
-  type Context,
-} from '@portabletext/editor/test/vitest'
-import {defineSchema} from '@portabletext/schema'
-import {Before} from 'racejar'
-import {Feature} from 'racejar/vitest'
-import {InputRulePlugin} from './plugin.input-rule'
-import {createStockTickerRule} from './rule.stock-ticker'
-import stockTickerFeature from './rule.stock-ticker.feature?raw'
-
-const stockTickerRule = createStockTickerRule({
-  stockTickerObject: (context) => ({
-    name: 'stock-ticker',
-    value: {
-      symbol: context.symbol,
-    },
-  }),
-})
-
-Feature({
-  hooks: [
-    Before(async (context: Context) => {
-      const {editor, locator} = await createTestEditor({
-        children: (
-          <>
-            <InputRulePlugin rules={[stockTickerRule]} />
-          </>
-        ),
-        schemaDefinition: defineSchema({
-          decorators: [{name: 'strong'}, {name: 'em'}],
-          annotations: [{name: 'link'}, {name: 'comment'}],
-          inlineObjects: [{name: 'stock-ticker'}],
-        }),
-      })
-
-      context.locator = locator
-      context.editor = editor
-    }),
-  ],
-  featureText: stockTickerFeature,
-  stepDefinitions,
-  parameterTypes,
-})

package/src/rule.stock-ticker.ts

@@ -1,79 +0,0 @@
-import type {EditorSchema} from '@portabletext/editor'
-import {raise} from '@portabletext/editor/behaviors'
-import {defineInputRule} from './input-rule'
-
-export function createStockTickerRule(config: {
-  stockTickerObject: (context: {
-    schema: EditorSchema
-    symbol: string
-  }) => {name: string; value?: {[prop: string]: unknown}} | undefined
-}) {
-  return defineInputRule({
-    on: /\{(.+)\}/,
-    guard: ({snapshot, event}) => {
-      const match = event.matches.at(0)
-
-      if (!match) {
-        return false
-      }
-
-      const symbolMatch = match.groupMatches.at(0)
-
-      if (symbolMatch === undefined) {
-        return false
-      }
-
-      const stockTickerObject = config.stockTickerObject({
-        schema: snapshot.context.schema,
-        symbol: symbolMatch.text,
-      })
-
-      if (!stockTickerObject) {
-        return false
-      }
-
-      return {match, stockTickerObject}
-    },
-    actions: [
-      ({snapshot, event}, {match, stockTickerObject}) => {
-        const stockTickerKey = snapshot.context.keyGenerator()
-
-        return [
-          raise({
-            type: 'delete',
-            at: match.targetOffsets,
-          }),
-          raise({
-            type: 'insert.child',
-            child: {
-              ...stockTickerObject.value,
-              _key: stockTickerKey,
-              _type: stockTickerObject.name,
-            },
-          }),
-          raise({
-            type: 'select',
-            at: {
-              anchor: {
-                path: [
-                  {_key: event.focusBlock.node._key},
-                  'children',
-                  {_key: stockTickerKey},
-                ],
-                offset: 0,
-              },
-              focus: {
-                path: [
-                  {_key: event.focusBlock.node._key},
-                  'children',
-                  {_key: stockTickerKey},
-                ],
-                offset: 0,
-              },
-            },
-          }),
-        ]
-      },
-    ],
-  })
-}

package/src/text-transform-rule.ts

@@ -1,105 +0,0 @@
-import {raise, type BehaviorAction} from '@portabletext/editor/behaviors'
-import {getMarkState} from '@portabletext/editor/selectors'
-import type {InputRule, InputRuleGuard} from './input-rule'
-import type {InputRuleMatchLocation} from './input-rule-match-location'
-
-/**
- * @alpha
- */
-export type TextTransformRule<TGuardResponse = true> = {
-  on: RegExp
-  guard?: InputRuleGuard<TGuardResponse>
-  transform: (
-    {location}: {location: InputRuleMatchLocation},
-    guardResponse: TGuardResponse,
-  ) => string
-}
-
-/**
- * Define an `InputRule` specifically designed to transform matched text into
- * some other text.
- *
- * @example
- * ```tsx
- * const transformRule = defineTextTransformRule({
- *   on: /--/,
- *   transform: () => '—',
- * })
- * ```
- *
- * @alpha
- */
-export function defineTextTransformRule<TGuardResponse = true>(
-  config: TextTransformRule<TGuardResponse>,
-): InputRule<TGuardResponse> {
-  return {
-    on: config.on,
-    guard: config.guard ?? (() => true as TGuardResponse),
-    actions: [
-      ({snapshot, event}, guardResponse) => {
-        const locations = event.matches.flatMap((match) =>
-          match.groupMatches.length === 0 ? [match] : match.groupMatches,
-        )
-        const newText = event.textBefore + event.textInserted
-
-        let textLengthDelta = 0
-        const actions: Array<BehaviorAction> = []
-
-        for (const location of locations.reverse()) {
-          const text = config.transform({location}, guardResponse)
-
-          textLengthDelta =
-            textLengthDelta -
-            (text.length -
-              (location.targetOffsets.focus.offset -
-                location.targetOffsets.anchor.offset))
-
-          actions.push(raise({type: 'select', at: location.targetOffsets}))
-          actions.push(raise({type: 'delete', at: location.targetOffsets}))
-          actions.push(
-            raise({
-              type: 'insert.child',
-              child: {
-                _type: snapshot.context.schema.span.name,
-                text,
-                marks:
-                  getMarkState({
-                    ...snapshot,
-                    context: {
-                      ...snapshot.context,
-                      selection: {
-                        anchor: location.selection.anchor,
-                        focus: {
-                          path: location.selection.focus.path,
-                          offset: Math.min(
-                            location.selection.focus.offset,
-                            event.textBefore.length,
-                          ),
-                        },
-                      },
-                    },
-                  })?.marks ?? [],
-              },
-            }),
-          )
-        }
-
-        const endCaretPosition = {
-          path: event.focusBlock.path,
-          offset: newText.length - textLengthDelta,
-        }
-
-        return [
-          ...actions,
-          raise({
-            type: 'select',
-            at: {
-              anchor: endCaretPosition,
-              focus: endCaretPosition,
-            },
-          }),
-        ]
-      },
-    ],
-  }
-}