@portabletext/plugin-typography 4.0.23 → 4.0.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/plugin-typography",
-  "version": "4.0.23",
+  "version": "4.0.24",
   "description": "Automatically transform text to typographic variants",
   "keywords": [
     "portabletext",
@@ -30,12 +30,11 @@
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "dependencies": {
     "react-compiler-runtime": "^1.0.0",
-    "@portabletext/plugin-input-rule": "^1.0.23"
+    "@portabletext/plugin-input-rule": "^1.0.24"
   },
   "devDependencies": {
     "@sanity/pkg-utils": "^10.1.1",
@@ -52,12 +51,12 @@
     "typescript": "5.9.3",
     "typescript-eslint": "^8.48.0",
     "vitest": "^4.0.14",
-    "@portabletext/editor": "^3.3.3",
-    "@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.3",
+    "@portabletext/editor": "^3.3.4",
     "react": "^18.3 || ^19"
   },
   "engines": {

package/src/create-decorator-guard.ts

@@ -1,70 +0,0 @@
-import type {EditorContext, EditorSchema} from '@portabletext/editor'
-import {
-  getSelectedSpans,
-  isActiveDecorator,
-} from '@portabletext/editor/selectors'
-import type {InputRuleGuard} from '@portabletext/plugin-input-rule'
-
-/**
- * @public
- * Create an `InputRuleGuard` that can prevent the rule from running inside
- * certain decorators.
- *
- * @example
- * ```tsx
- * const guard = createDecoratorGuard({
- *  decorators: ({context}) => context.schema.decorators.flatMap((decorator) => decorator.name === 'code' ? [] : [decorator.name]),
- * })
- *
- * <TypographyPlugin guard={guard} />
- * ```
- */
-export function createDecoratorGuard(config: {
-  decorators: ({
-    context,
-  }: {
-    context: Pick<EditorContext, 'schema'>
-  }) => Array<EditorSchema['decorators'][number]['name']>
-}): InputRuleGuard {
-  return ({snapshot, event}) => {
-    const allowedDecorators = config.decorators({
-      context: {
-        schema: snapshot.context.schema,
-      },
-    })
-    const decorators = snapshot.context.schema.decorators.flatMap(
-      (decorator) =>
-        allowedDecorators.includes(decorator.name) ? [] : [decorator.name],
-    )
-
-    if (decorators.length === 0) {
-      return true
-    }
-
-    const matchedSpans = event.matches.flatMap((match) =>
-      getSelectedSpans({
-        ...snapshot,
-        context: {
-          ...snapshot.context,
-          selection: match.selection,
-        },
-      }),
-    )
-
-    let preventInputRule = false
-
-    for (const decorator of decorators) {
-      if (isActiveDecorator(decorator)(snapshot)) {
-        preventInputRule = true
-        break
-      }
-
-      if (matchedSpans.some((span) => span.node.marks?.includes(decorator))) {
-        preventInputRule = true
-        break
-      }
-    }
-
-    return !preventInputRule
-  }
-}

package/src/disallow-in-code.feature

@@ -1,53 +0,0 @@
-Feature: Disallow in code
-
-  Scenario Outline: Decorated text
-    Given the text <text>
-    And "code" around <decorated>
-    When the caret is put <position>
-    And "->" is typed
-    Then the text is <new text>
-
-    Examples:
-      | text          | decorated | position        | new text          |
-      | "foo"         | "foo"     | after "foo"     | "foo->"           |
-      | "foo bar baz" | "bar"     | after "bar"     | "foo ,bar->, baz" |
-      | "foo bar baz" | "bar"     | before "bar"    | "foo →,bar, baz"  |
-      | "foo bar baz" | "bar"     | before "ar baz" | "foo ,b->ar, baz" |
-
-  Scenario Outline: Partially decorated text
-    Given the text "foo bar2x baz"
-    And "code" around "bar2x"
-    When the caret is put after "bar2x"
-    And "2" is typed
-    Then the text is "foo ,bar2x2, baz"
-
-  Scenario Outline: Partially decorated text with decorator toggled off
-    Given the text <text>
-    And "code" around <decorated>
-    When the caret is put <position>
-    And "code" is toggled
-    And <inserted text> is typed
-    Then the text is <new text>
-
-    Examples:
-      | text            | decorated | position      | inserted text | new text           |
-      | "foo bar baz"   | "bar"     | after "bar"   | "2x2"         | "foo ,bar,2×2 baz" |
-      | "foo bar2 baz"  | "bar2"    | after "bar2"  | "x2"          | "foo ,bar2,x2 baz" |
-      | "foo bar2x baz" | "bar2x"   | after "bar2x" | "2"           | "foo ,bar2x,2 baz" |
-
-  Scenario Outline: Decorated and annotated text
-    Given the text "foo bar baz"
-    And <decorator> around "bar"
-    And a "link" "l1" around "bar"
-    When the caret is put <position>
-    And "->" is typed
-    Then the text is <new text>
-
-    Examples:
-      | decorator | position        | new text          |
-      | "code"    | after "bar"     | "foo ,bar,→ baz"  |
-      | "strong"  | after "bar"     | "foo ,bar,→ baz"  |
-      | "code"    | before "bar"    | "foo →,bar, baz"  |
-      | "strong"  | before "bar"    | "foo →,bar, baz"  |
-      | "code"    | before "ar baz" | "foo ,b->ar, baz" |
-      | "strong"  | before "ar baz" | "foo ,b→ar, baz"  |

package/src/disallow-in-code.test.tsx

@@ -1,41 +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 {createDecoratorGuard} from './create-decorator-guard'
-import disallowInCodeFeature from './disallow-in-code.feature?raw'
-import {TypographyPlugin} from './plugin.typography'
-
-const codeGuard = createDecoratorGuard({
-  decorators: ({context}) =>
-    context.schema.decorators.flatMap((decorator) =>
-      decorator.name === 'code' ? [] : [decorator.name],
-    ),
-})
-
-Feature({
-  hooks: [
-    Before(async (context: Context) => {
-      const {editor, locator} = await createTestEditor({
-        children: (
-          <TypographyPlugin guard={codeGuard} enable={['multiplication']} />
-        ),
-        schemaDefinition: defineSchema({
-          decorators: [{name: 'strong'}, {name: 'code'}],
-          annotations: [{name: 'link'}],
-        }),
-      })
-
-      context.locator = locator
-      context.editor = editor
-    }),
-  ],
-  featureText: disallowInCodeFeature,
-  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,3 +0,0 @@
-export * from './create-decorator-guard'
-export * from './input-rules.typography'
-export * from './plugin.typography'

package/src/input-rule.ellipsis.feature

@@ -1,95 +0,0 @@
-Feature: Ellipsis Input Rule
-
-  Background:
-    Given a global keymap
-
-  Scenario Outline: Inserting ellipsis in unformatted text
-    Given the text <text>
-    # The "When {string} is inserted" step inserts all characters at once to
-    # mimic how insert.text behaves on Android
-    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           |
-      | ".."           | "."            | "…"                | "..."                |
-      | ""             | "..."          | "…"                | "..."                |
-      | "foo"          | "..."          | "foo…"             | "foo..."             |
-      | ""             | "foo..."       | "foo…"             | "foo..."             |
-      | "foo.."        | ".bar"         | "foo…bar"          | "foo...bar"          |
-      | ""             | "foo...bar..." | "foo…bar…"         | "foo...bar..."       |
-      | "foo...bar..." | "baz..."       | "foo...bar...baz…" | "foo...bar...baz..." |
-
-  Scenario: Inserting ellipsis inside a decorator
-    Given the text "foo.."
-    And "strong" around "foo.."
-    When the caret is put after "foo.."
-    And "." is typed
-    Then the text is "foo…"
-    And "foo…" has marks "strong"
-
-  Scenario: Inserting ellipsis at the edge of a decorator
-    Given the text "foo.."
-    And "strong" around "foo"
-    When the caret is put after "foo.."
-    And "." is typed
-    Then the text is "foo,…"
-    And "foo" has marks "strong"
-    And "…" has no marks
-
-  Scenario: Inserting ellipsis inside an annotation
-    Given the text "foo.."
-    And a "link" "l1" around "foo.."
-    When the caret is put after "foo.."
-    And "." is typed
-    Then the text is "foo…"
-    And "foo…" has marks "l1"
-
-  Scenario: Inserting ellipsis at the edge of an annotation
-    Given the text "foo.."
-    And a "link" "l1" around "foo"
-    When the caret is put after "foo.."
-    And "." is typed
-    Then the text is "foo,…"
-    And "foo" has marks "l1"
-    And "…" has no marks
-
-  Scenario Outline: Smart undo with Backspace
-    Given the text <text>
-    When <inserted text> is inserted
-    And "{Backspace}" is pressed
-    Then the text is <new text>
-
-    Examples:
-      | text           | inserted text  | new text             |
-      | ".."           | "."            | "..."                |
-      | ""             | "..."          | "..."                |
-      | "foo"          | "..."          | "foo..."             |
-      | ""             | "foo..."       | "foo..."             |
-      | "foo.."        | ".bar"         | "foo...bar"          |
-      | ""             | "foo...bar..." | "foo...bar..."       |
-      | "foo...bar..." | "baz..."       | "foo...bar...baz..." |
-
-  Scenario Outline: Smart undo aborted after text changes
-    Given the text <text>
-    When <inserted text> is inserted
-    And <new text> is typed
-    And "{Backspace}" is pressed
-    Then the text is <final text>
-
-    Examples:
-      | text | inserted text | new text | final text |
-      | ""   | "..."         | "n"      | "…"        |
-
-  Scenario Outline: Smart undo aborted after selection changes
-    Given the text <text>
-    When <inserted text> is inserted
-    And "{ArrowLeft}" is pressed
-    And "{Backspace}" is pressed
-    Then the text is <final text>
-
-    Examples:
-      | text  | inserted text | final text |
-      | "foo" | "..."         | "fo…"      |

package/src/input-rule.ellipsis.test.tsx

@@ -1,31 +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 ellipsisFeature from './input-rule.ellipsis.feature?raw'
-import {TypographyPlugin} from './plugin.typography'
-
-Feature({
-  hooks: [
-    Before(async (context: Context) => {
-      const {editor, locator} = await createTestEditor({
-        children: <TypographyPlugin />,
-        schemaDefinition: defineSchema({
-          decorators: [{name: 'strong'}],
-          annotations: [{name: 'link'}],
-        }),
-      })
-
-      context.locator = locator
-      context.editor = editor
-    }),
-  ],
-  featureText: ellipsisFeature,
-  stepDefinitions,
-  parameterTypes,
-})

package/src/input-rule.em-dash.feature

@@ -1,103 +0,0 @@
-Feature: Em Dash Input Rule
-
-  Background:
-    Given a global keymap
-
-  Scenario Outline: Inserting em dash in unformatted text
-    Given the text <text>
-    # The "When {string} is inserted" step inserts all characters at once to
-    # mimic how insert.text behaves on Android
-    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        |
-      | "-"          | "-"           | "—"              | "--"              |
-      | ""           | "--"          | "—"              | "--"              |
-      | "foo"        | "--"          | "foo—"           | "foo--"           |
-      | ""           | "foo--"       | "foo—"           | "foo--"           |
-      | "foo-"       | "-bar"        | "foo—bar"        | "foo--bar"        |
-      | ""           | "foo--bar--"  | "foo—bar—"       | "foo--bar--"      |
-      | "foo--bar--" | "baz--"       | "foo--bar--baz—" | "foo--bar--baz--" |
-
-  Scenario: Inserting em dash inside a decorator
-    Given the text "foo-"
-    And "strong" around "foo-"
-    When the caret is put after "foo-"
-    And "-" is typed
-    Then the text is "foo—"
-    And "foo—" has marks "strong"
-
-  Scenario: Inserting em dash at the edge of a decorator
-    Given the text "foo-"
-    And "strong" around "foo"
-    When the caret is put after "foo-"
-    And "-" is typed
-    Then the text is "foo,—"
-    And "foo" has marks "strong"
-    And "—" has no marks
-
-  Scenario: Inserting em dash inside an annotation
-    Given the text "foo-"
-    And a "link" "l1" around "foo-"
-    When the caret is put after "foo-"
-    And "-" is typed
-    Then the text is "foo—"
-    And "foo—" has marks "l1"
-
-  Scenario: Inserting em dash halfway inside an annotation
-    Given the text "foo-"
-    And a "link" "l1" around "foo-"
-    When the caret is put after "foo-"
-    And "-" is typed
-    Then the text is "foo—"
-    And "foo—" has marks "l1"
-
-  Scenario: Inserting em dash at the edge of an annotation
-    Given the text "foo-"
-    And a "link" "l1" around "foo"
-    When the caret is put after "foo-"
-    And "-" is typed
-    Then the text is "foo,—"
-    And "foo" has marks "l1"
-    And "—" has no marks
-
-  Scenario Outline: Smart undo with Backspace
-    Given the text <text>
-    When <inserted text> is inserted
-    And "{Backspace}" is pressed
-    Then the text is <new text>
-
-    Examples:
-      | text         | inserted text | new text          |
-      | "-"          | "-"           | "--"              |
-      | ""           | "--"          | "--"              |
-      | "foo"        | "--"          | "foo--"           |
-      | ""           | "foo--"       | "foo--"           |
-      | "foo-"       | "-bar"        | "foo--bar"        |
-      | ""           | "foo--bar--"  | "foo--bar--"      |
-      | "foo--bar--" | "baz--"       | "foo--bar--baz--" |
-
-  Scenario Outline: Smart undo aborted after text changes
-    Given the text <text>
-    When <inserted text> is inserted
-    And <new text> is typed
-    And "{Backspace}" is pressed
-    Then the text is <final text>
-
-    Examples:
-      | text | inserted text | new text | final text |
-      | ""   | "--"          | "n"      | "—"        |
-
-  Scenario Outline: Smart undo aborted after selection changes
-    Given the text <text>
-    When <inserted text> is inserted
-    And "{ArrowLeft}" is pressed
-    And "{Backspace}" is pressed
-    Then the text is <final text>
-
-    Examples:
-      | text  | inserted text | final text |
-      | "foo" | "--"          | "fo—"      |

package/src/input-rule.em-dash.test.tsx

@@ -1,31 +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 emDashFeature from './input-rule.em-dash.feature?raw'
-import {TypographyPlugin} from './plugin.typography'
-
-Feature({
-  hooks: [
-    Before(async (context: Context) => {
-      const {editor, locator} = await createTestEditor({
-        children: <TypographyPlugin />,
-        schemaDefinition: defineSchema({
-          decorators: [{name: 'strong'}],
-          annotations: [{name: 'link'}],
-        }),
-      })
-
-      context.locator = locator
-      context.editor = editor
-    }),
-  ],
-  featureText: emDashFeature,
-  stepDefinitions,
-  parameterTypes,
-})

package/src/input-rule.multiplication.feature

@@ -1,22 +0,0 @@
-Feature: Multiplication Input Rule
-
-  Scenario Outline: Inserting multiplication sign
-    Given the text <text>
-    When <inserted text> is inserted
-    Then the text is <new text>
-
-    Examples:
-      | text | inserted text | new text |
-      | ""   | "1*2"         | "1×2"    |
-      | ""   | "1*2*3"       | "1×2×3"  |
-
-  Scenario Outline: Inserting multiplication sign and writing afterwards
-    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   |
-      | ""   | "1*2"         | "1×2new"   |
-      | ""   | "1*2*3"       | "1×2×3new" |

package/src/input-rule.multiplication.test.tsx

@@ -1,31 +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 multiplicationFeature from './input-rule.multiplication.feature?raw'
-import {TypographyPlugin} from './plugin.typography'
-
-Feature({
-  hooks: [
-    Before(async (context: Context) => {
-      const {editor, locator} = await createTestEditor({
-        children: <TypographyPlugin enable={['multiplication']} />,
-        schemaDefinition: defineSchema({
-          decorators: [{name: 'strong'}],
-          annotations: [{name: 'link'}],
-        }),
-      })
-
-      context.locator = locator
-      context.editor = editor
-    }),
-  ],
-  featureText: multiplicationFeature,
-  stepDefinitions,
-  parameterTypes,
-})

package/src/input-rule.smart-quotes.feature

@@ -1,72 +0,0 @@
-Feature: Smart Quotes Input Rule
-
-  Background:
-    Given a global keymap
-
-  Scenario Outline: Typing turns double quotes into smart quotes
-    Given the text <text>
-    When <inserted text> is typed
-    Then the text is <new text>
-
-    Examples:
-      | text    | inserted text     | new text      |
-      | ""      | "\"foo\""         | "“foo”"       |
-      | "“foo”" | " \"bar\""        | "“foo” “bar”" |
-      | ""      | "\"foo\" \"bar\"" | "“foo” “bar”" |
-
-  Scenario Outline: Inserting double smart quotes in unformatted text
-    Given the text <text>
-    # The "When {string} is inserted" step inserts all characters at once to
-    # mimic how insert.text behaves on Android
-    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   |
-      | ""      | "\""          | "“"          | """          |
-      | ""      | "\"\""        | "““"         | """"         |
-      | ""      | "\"\"\""      | "“““"        | """""        |
-      | "”"     | "\""          | "””"         | "”""         |
-      # | "”"  | "\"\""        | "”””"       | "””""      |
-      | ""      | "\"foo\""     | "“foo”"      | ""foo""      |
-      | "“foo"  | "\""          | "“foo”"      | "“foo""      |
-      | ""foo"  | "\""          | ""foo”"      | ""foo""      |
-      | ""foo"" | "\"bar\""     | ""foo"“bar”" | ""foo""bar"" |
-      | "“foo”" | "\""          | "“foo””"     | "“foo”""     |
-
-  # | "“foo”" | "\"\""        | "“foo”””"    | "“foo”"""    |
-  Scenario Outline: Inserting single smart quotes in unformatted text
-    Given the text <text>
-    # The "When {string} is inserted" step inserts all characters at once to
-    # mimic how insert.text behaves on Android
-    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   |
-      | ""      | "'"           | "‘"          | "'"          |
-      | ""      | "'foo'"       | "‘foo’"      | "'foo'"      |
-      | "‘foo"  | "'"           | "‘foo’"      | "‘foo'"      |
-      | "'foo"  | "'"           | "'foo’"      | "'foo'"      |
-      | "'foo'" | "'bar'"       | "'foo'‘bar’" | "'foo''bar'" |
-
-  Scenario: Mixed quotes
-    Given the text ""
-    When "\"'sorry' you say?\" she asked" is typed
-    Then the text is "“‘sorry’ you say?” she asked"
-
-  Scenario Outline: Contractions
-    When <text> is typed
-    Then the text is <new text>
-
-    Examples:
-      | text     | new text |
-      | "it's"   | "it’s"   |
-      | "don't"  | "don’t"  |
-      | "won't"  | "won’t"  |
-      | "I'm"    | "I’m"    |
-      | "you're" | "you’re" |

package/src/input-rule.smart-quotes.test.tsx

@@ -1,31 +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 smartQuotesFeature from './input-rule.smart-quotes.feature?raw'
-import {TypographyPlugin} from './plugin.typography'
-
-Feature({
-  hooks: [
-    Before(async (context: Context) => {
-      const {editor, locator} = await createTestEditor({
-        children: <TypographyPlugin />,
-        schemaDefinition: defineSchema({
-          decorators: [{name: 'strong'}],
-          annotations: [{name: 'link'}],
-        }),
-      })
-
-      context.locator = locator
-      context.editor = editor
-    }),
-  ],
-  featureText: smartQuotesFeature,
-  stepDefinitions,
-  parameterTypes,
-})

package/src/input-rules.typography.ts

@@ -1,190 +0,0 @@
-import {
-  defineTextTransformRule,
-  type InputRule,
-} from '@portabletext/plugin-input-rule'
-
-/**
- * @public
- */
-export const emDashRule = defineTextTransformRule({
-  on: /--/,
-  transform: () => '—',
-})
-
-/**
- * @public
- */
-export const ellipsisRule = defineTextTransformRule({
-  on: /\.\.\./,
-  transform: () => '…',
-})
-
-/**
- * @public
- */
-export const openingDoubleQuoteRule = defineTextTransformRule({
-  on: /(?:^|(?<=[\s{[(<'"\u2018\u201C]))"/g,
-  transform: () => '“',
-})
-
-/**
- * @public
- */
-export const closingDoubleQuoteRule = defineTextTransformRule({
-  on: /"/g,
-  transform: () => '”',
-})
-
-/**
- * @public
- */
-export const openingSingleQuoteRule = defineTextTransformRule({
-  on: /(?:^|(?<=[\s{[(<'"\u2018\u201C]))'/g,
-  transform: () => '‘',
-})
-
-/**
- * @public
- */
-export const closingSingleQuoteRule = defineTextTransformRule({
-  on: /'/g,
-  transform: () => '’',
-})
-
-/**
- * @public
- */
-export const smartQuotesRules: Array<InputRule> = [
-  openingDoubleQuoteRule,
-  closingDoubleQuoteRule,
-  openingSingleQuoteRule,
-  closingSingleQuoteRule,
-]
-
-/**
- * @public
- */
-export const leftArrowRule = defineTextTransformRule({
-  on: /<-/,
-  transform: () => '←',
-})
-
-/**
- * @public
- */
-export const rightArrowRule = defineTextTransformRule({
-  on: /->/,
-  transform: () => '→',
-})
-
-/**
- * @public
- */
-export const copyrightRule = defineTextTransformRule({
-  on: /\(c\)/,
-  transform: () => '©',
-})
-
-/**
- * @public
- */
-export const servicemarkRule = defineTextTransformRule({
-  on: /\(sm\)/,
-  transform: () => '℠',
-})
-
-/**
- * @public
- */
-export const trademarkRule = defineTextTransformRule({
-  on: /\(tm\)/,
-  transform: () => '™',
-})
-
-/**
- * @beta
- */
-export const registeredTrademarkRule = defineTextTransformRule({
-  on: /\(r\)/,
-  transform: () => '®',
-})
-
-/**
- * @public
- */
-export const oneHalfRule = defineTextTransformRule({
-  on: /(?:^|\s)(1\/2)\s/,
-  transform: () => '½',
-})
-
-/**
- * @public
- */
-export const plusMinusRule = defineTextTransformRule({
-  on: /\+\/-/,
-  transform: () => '±',
-})
-
-/**
- * @public
- */
-export const notEqualRule = defineTextTransformRule({
-  on: /!=/,
-  transform: () => '≠',
-})
-
-/**
- * @public
- */
-export const laquoRule = defineTextTransformRule({
-  on: /<</,
-  transform: () => '«',
-})
-
-/**
- * @public
- */
-export const raquoRule = defineTextTransformRule({
-  on: />>/,
-  transform: () => '»',
-})
-
-/**
- * @public
- */
-export const multiplicationRule = defineTextTransformRule({
-  on: /\d+\s?([*x])\s?\d+/,
-  transform: () => '×',
-})
-
-/**
- * @public
- */
-export const superscriptTwoRule = defineTextTransformRule({
-  on: /\^2/,
-  transform: () => '²',
-})
-
-/**
- * @public
- */
-export const superscriptThreeRule = defineTextTransformRule({
-  on: /\^3/,
-  transform: () => '³',
-})
-
-/**
- * @public
- */
-export const oneQuarterRule = defineTextTransformRule({
-  on: /(?:^|\s)(1\/4)\s/,
-  transform: () => '¼',
-})
-
-/**
- * @public
- */
-export const threeQuartersRule = defineTextTransformRule({
-  on: /(?:^|\s)(3\/4)\s/,
-  transform: () => '¾',
-})

package/src/plugin.typography.tsx

@@ -1,147 +0,0 @@
-import {
-  InputRulePlugin,
-  type InputRuleGuard,
-} from '@portabletext/plugin-input-rule'
-import {useMemo} from 'react'
-import {
-  closingDoubleQuoteRule,
-  closingSingleQuoteRule,
-  copyrightRule,
-  ellipsisRule,
-  emDashRule,
-  laquoRule,
-  leftArrowRule,
-  multiplicationRule,
-  notEqualRule,
-  oneHalfRule,
-  oneQuarterRule,
-  openingDoubleQuoteRule,
-  openingSingleQuoteRule,
-  plusMinusRule,
-  raquoRule,
-  registeredTrademarkRule,
-  rightArrowRule,
-  servicemarkRule,
-  superscriptThreeRule,
-  superscriptTwoRule,
-  threeQuartersRule,
-  trademarkRule,
-} from './input-rules.typography'
-
-const defaultRuleConfig = [
-  {name: 'emDash', rule: emDashRule, state: 'on'},
-  {name: 'ellipsis', rule: ellipsisRule, state: 'on'},
-  {name: 'openingDoubleQuote', rule: openingDoubleQuoteRule, state: 'on'},
-  {name: 'closingDoubleQuote', rule: closingDoubleQuoteRule, state: 'on'},
-  {name: 'openingSingleQuote', rule: openingSingleQuoteRule, state: 'on'},
-  {name: 'closingSingleQuote', rule: closingSingleQuoteRule, state: 'on'},
-  {name: 'leftArrow', rule: leftArrowRule, state: 'on'},
-  {name: 'rightArrow', rule: rightArrowRule, state: 'on'},
-  {name: 'copyright', rule: copyrightRule, state: 'on'},
-  {name: 'trademark', rule: trademarkRule, state: 'on'},
-  {name: 'servicemark', rule: servicemarkRule, state: 'on'},
-  {name: 'registeredTrademark', rule: registeredTrademarkRule, state: 'on'},
-  {name: 'oneHalf', rule: oneHalfRule, state: 'off'},
-  {name: 'plusMinus', rule: plusMinusRule, state: 'off'},
-  {name: 'laquo', rule: laquoRule, state: 'off'},
-  {name: 'notEqual', rule: notEqualRule, state: 'off'},
-  {name: 'raquo', rule: raquoRule, state: 'off'},
-  {name: 'multiplication', rule: multiplicationRule, state: 'off'},
-  {name: 'superscriptTwo', rule: superscriptTwoRule, state: 'off'},
-  {name: 'superscriptThree', rule: superscriptThreeRule, state: 'off'},
-  {name: 'oneQuarter', rule: oneQuarterRule, state: 'off'},
-  {name: 'threeQuarters', rule: threeQuartersRule, state: 'off'},
-] as const
-
-type RuleName = (typeof defaultRuleConfig)[number]['name']
-
-/**
- * @public
- */
-export type TypographyPluginProps<
-  TEnabledRuleName extends RuleName = never,
-  TDisabledRuleName extends Exclude<RuleName, TEnabledRuleName> = never,
-> = {
-  guard?: InputRuleGuard
-  /**
-   * Preset configuration for rules.
-   * - `'default'`: Common typography rules enabled (em dash, ellipsis, quotes, arrows, copyright symbols)
-   * - `'all'`: All rules enabled
-   * - `'none'`: No rules enabled (use with `enable` prop)
-   *
-   * @defaultValue 'default'
-   */
-  preset?: 'default' | 'all' | 'none'
-  /**
-   * Enable specific rules (additive to preset).
-   * Use this to enable additional rules beyond the preset.
-   *
-   * @example
-   * ```tsx
-   * // Enable multiplication and plusMinus in addition to default rules
-   * <TypographyPlugin enable={['multiplication', 'plusMinus']} />
-   * ```
-   */
-  enable?: ReadonlyArray<TEnabledRuleName>
-  /**
-   * Disable specific rules (subtractive from preset).
-   * Use this to disable rules that would otherwise be enabled by the preset.
-   * Cannot contain rules that are in the `enable` array (TypeScript will enforce this).
-   *
-   * @example
-   * ```tsx
-   * // Disable em dash from the default rules
-   * <TypographyPlugin disable={['emDash']} />
-   * ```
-   */
-  disable?: ReadonlyArray<TDisabledRuleName>
-}
-
-/**
- * @public
- */
-export function TypographyPlugin<
-  TEnabledRuleName extends RuleName = never,
-  TDisabledRuleName extends Exclude<RuleName, TEnabledRuleName> = never,
->(props: TypographyPluginProps<TEnabledRuleName, TDisabledRuleName>) {
-  const {preset = 'default', enable = [], disable = [], guard} = props
-
-  const configuredInputRules = useMemo(() => {
-    // Determine which rules should be enabled based on preset
-    const enabledRules = new Set<RuleName>()
-
-    if (preset === 'all') {
-      // Enable all rules
-      for (const rule of defaultRuleConfig) {
-        enabledRules.add(rule.name)
-      }
-    } else if (preset === 'default') {
-      // Enable only default rules (state: 'on')
-      for (const rule of defaultRuleConfig) {
-        if (rule.state === 'on') {
-          enabledRules.add(rule.name)
-        }
-      }
-    }
-    // preset === 'none' starts with empty set
-
-    // Apply enable list (additive)
-    for (const ruleName of enable) {
-      enabledRules.add(ruleName)
-    }
-
-    // Apply disable list (subtractive)
-    for (const ruleName of disable) {
-      enabledRules.delete(ruleName)
-    }
-
-    // Build final rule list
-    return defaultRuleConfig.flatMap((rule) =>
-      enabledRules.has(rule.name)
-        ? [{...rule.rule, guard: guard ?? (() => true)}]
-        : [],
-    )
-  }, [preset, enable, disable, guard])
-
-  return <InputRulePlugin rules={configuredInputRules} />
-}