@portabletext/editor 1.46.0 → 1.47.1

package/src/editor/plugins/createWithPortableTextMarkModel.ts

@@ -13,21 +13,19 @@ import {debugWithName} from '../../internal-utils/debug'
 import {getNextSpan, getPreviousSpan} from '../../internal-utils/sibling-utils'
 import {isChangingRemotely} from '../../internal-utils/withChanges'
 import {isRedoing, isUndoing} from '../../internal-utils/withUndoRedo'
-import type {
-  PortableTextMemberSchemaTypes,
-  PortableTextSlateEditor,
-} from '../../types/editor'
+import type {PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
 
 const debug = debugWithName('plugin:withPortableTextMarkModel')
 
 export function createWithPortableTextMarkModel(
   editorActor: EditorActor,
-  types: PortableTextMemberSchemaTypes,
 ): (editor: PortableTextSlateEditor) => PortableTextSlateEditor {
   return function withPortableTextMarkModel(editor: PortableTextSlateEditor) {
     const {apply, normalizeNode} = editor
-    const decorators = types.decorators.map((t) => t.value)
+    const decorators = editorActor
+      .getSnapshot()
+      .context.schema.decorators.map((t) => t.name)
 
     // Extend Slate's default normalization. Merge spans with same set of .marks when doing merge_node operations, and clean up markDefs / marks
     editor.normalizeNode = (nodeEntry) => {
@@ -89,7 +87,9 @@ export function createWithPortableTextMarkModel(
       if (editor.isTextSpan(node)) {
         const blockPath = Path.parent(path)
         const [block] = Editor.node(editor, blockPath)
-        const decorators = types.decorators.map((decorator) => decorator.value)
+        const decorators = editorActor
+          .getSnapshot()
+          .context.schema.decorators.map((decorator) => decorator.name)
         const annotations = node.marks?.filter(
           (mark) => !decorators.includes(mark),
         )
@@ -113,7 +113,9 @@ export function createWithPortableTextMarkModel(
        * Remove orphaned annotations from child spans of block nodes
        */
       if (editor.isTextBlock(node)) {
-        const decorators = types.decorators.map((decorator) => decorator.value)
+        const decorators = editorActor
+          .getSnapshot()
+          .context.schema.decorators.map((decorator) => decorator.name)
 
         for (const [child, childPath] of Node.children(editor, path)) {
           if (editor.isTextSpan(child)) {
@@ -152,9 +154,9 @@ export function createWithPortableTextMarkModel(
         const [block] = Editor.node(editor, blockPath)
 
         if (editor.isTextBlock(block)) {
-          const decorators = types.decorators.map(
-            (decorator) => decorator.value,
-          )
+          const decorators = editorActor
+            .getSnapshot()
+            .context.schema.decorators.map((decorator) => decorator.name)
           const marks = node.marks ?? []
           const orphanedAnnotations = marks.filter((mark) => {
             return (
@@ -627,7 +629,8 @@ export function createWithPortableTextMarkModel(
         op.type === 'merge_node' &&
         op.path.length === 1 &&
         'markDefs' in op.properties &&
-        op.properties._type === types.block.name &&
+        op.properties._type ===
+          editorActor.getSnapshot().context.schema.block.name &&
         Array.isArray(op.properties.markDefs) &&
         op.properties.markDefs.length > 0 &&
         op.path[0] - 1 >= 0

package/src/editor/plugins/createWithSchemaTypes.ts

@@ -8,10 +8,7 @@ import {
 } from '@sanity/types'
 import {Transforms, type Element} from 'slate'
 import {debugWithName} from '../../internal-utils/debug'
-import type {
-  PortableTextMemberSchemaTypes,
-  PortableTextSlateEditor,
-} from '../../types/editor'
+import type {PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
 
 const debug = debugWithName('plugin:withSchemaTypes')
@@ -21,40 +18,47 @@ const debug = debugWithName('plugin:withSchemaTypes')
  */
 export function createWithSchemaTypes({
   editorActor,
-  schemaTypes,
 }: {
   editorActor: EditorActor
-  schemaTypes: PortableTextMemberSchemaTypes
 }) {
   return function withSchemaTypes(
     editor: PortableTextSlateEditor,
   ): PortableTextSlateEditor {
     editor.isTextBlock = (value: unknown): value is PortableTextTextBlock => {
       return (
-        isPortableTextTextBlock(value) && value._type === schemaTypes.block.name
+        isPortableTextTextBlock(value) &&
+        value._type === editorActor.getSnapshot().context.schema.block.name
       )
     }
     editor.isTextSpan = (value: unknown): value is PortableTextSpan => {
-      return isPortableTextSpan(value) && value._type === schemaTypes.span.name
+      return (
+        isPortableTextSpan(value) &&
+        value._type === editorActor.getSnapshot().context.schema.span.name
+      )
     }
     editor.isListBlock = (value: unknown): value is PortableTextListBlock => {
       return (
-        isPortableTextListBlock(value) && value._type === schemaTypes.block.name
+        isPortableTextListBlock(value) &&
+        value._type === editorActor.getSnapshot().context.schema.block.name
       )
     }
     editor.isVoid = (element: Element): boolean => {
       return (
-        schemaTypes.block.name !== element._type &&
-        (schemaTypes.blockObjects
-          .map((obj) => obj.name)
+        editorActor.getSnapshot().context.schema.block.name !== element._type &&
+        (editorActor
+          .getSnapshot()
+          .context.schema.blockObjects.map((obj) => obj.name)
           .includes(element._type) ||
-          schemaTypes.inlineObjects
-            .map((obj) => obj.name)
+          editorActor
+            .getSnapshot()
+            .context.schema.inlineObjects.map((obj) => obj.name)
             .includes(element._type))
       )
     }
     editor.isInline = (element: Element): boolean => {
-      const inlineSchemaTypes = schemaTypes.inlineObjects.map((obj) => obj.name)
+      const inlineSchemaTypes = editorActor
+        .getSnapshot()
+        .context.schema.inlineObjects.map((obj) => obj.name)
       return (
         inlineSchemaTypes.includes(element._type) &&
         '__inline' in element &&
@@ -76,7 +80,11 @@ export function createWithSchemaTypes({
         editorActor.send({type: 'normalizing'})
         Transforms.setNodes(
           editor,
-          {...span, _type: schemaTypes.span.name, _key: key},
+          {
+            ...span,
+            _type: editorActor.getSnapshot().context.schema.span.name,
+            _key: key,
+          },
           {at: path},
         )
         editorActor.send({type: 'done normalizing'})

package/src/editor/plugins/createWithUndoRedo.ts

@@ -10,7 +10,7 @@ import {
   DIFF_INSERT,
   parsePatch,
 } from '@sanity/diff-match-patch'
-import type {ObjectSchemaType, PortableTextBlock} from '@sanity/types'
+import type {PortableTextBlock} from '@sanity/types'
 import {flatten, isEqual} from 'lodash'
 import {
   Editor,
@@ -58,7 +58,6 @@ const isSaving = (editor: Editor): boolean | undefined => {
 
 export interface Options {
   editorActor: EditorActor
-  blockSchemaType: ObjectSchemaType
   subscriptions: Array<() => () => void>
 }
 
@@ -72,12 +71,12 @@ const getRemotePatches = (editor: Editor) => {
 export function createWithUndoRedo(
   options: Options,
 ): (editor: PortableTextSlateEditor) => PortableTextSlateEditor {
-  const {editorActor, blockSchemaType} = options
+  const {editorActor} = options
 
   return (editor: PortableTextSlateEditor) => {
     let previousSnapshot: PortableTextBlock[] | undefined = fromSlateValue(
       editor.children,
-      blockSchemaType.name,
+      editorActor.getSnapshot().context.schema.block.name,
     )
     const remotePatches = getRemotePatches(editor)
     let previousBehaviorActionSetId = getCurrentBehaviorActionSetId(editor)

package/src/editor/plugins/createWithUtils.ts

@@ -1,20 +1,16 @@
 import {toSlateValue} from '../../internal-utils/values'
-import type {
-  PortableTextMemberSchemaTypes,
-  PortableTextSlateEditor,
-} from '../../types/editor'
+import type {PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
 
 interface Options {
   editorActor: EditorActor
-  schemaTypes: PortableTextMemberSchemaTypes
 }
 
 /**
  * This plugin makes various util commands available in the editor
  *
  */
-export function createWithUtils({editorActor, schemaTypes}: Options) {
+export function createWithUtils({editorActor}: Options) {
   return function withUtils(
     editor: PortableTextSlateEditor,
   ): PortableTextSlateEditor {
@@ -26,9 +22,11 @@ export function createWithUtils({editorActor, schemaTypes}: Options) {
       const block = toSlateValue(
         [
           {
-            _type: schemaTypes.block.name,
+            _type: editorActor.getSnapshot().context.schema.block.name,
             _key: editorActor.getSnapshot().context.keyGenerator(),
-            style: schemaTypes.styles[0].value || 'normal',
+            style:
+              editorActor.getSnapshot().context.schema.styles[0].name ||
+              'normal',
             ...(options.listItem ? {listItem: options.listItem} : {}),
             ...(options.level ? {level: options.level} : {}),
             markDefs: [],
@@ -38,13 +36,17 @@ export function createWithUtils({editorActor, schemaTypes}: Options) {
                 _key: editorActor.getSnapshot().context.keyGenerator(),
                 text: '',
                 marks: options.decorators.filter((decorator) =>
-                  schemaTypes.decorators.find(({value}) => value === decorator),
+                  editorActor
+                    .getSnapshot()
+                    .context.schema.decorators.find(
+                      ({name}) => name === decorator,
+                    ),
                 ),
               },
             ],
           },
         ],
-        {schemaTypes},
+        {schemaTypes: editorActor.getSnapshot().context.schema},
       )[0]
       return block
     }

package/src/editor/plugins/with-plugins.ts

@@ -31,39 +31,29 @@ export const withPlugins = <T extends Editor>(
 ): PortableTextSlateEditor => {
   const e = editor as T & PortableTextSlateEditor
   const {editorActor} = options
-  const schemaTypes = editorActor.getSnapshot().context.schema
-  const operationToPatches = createOperationToPatches(schemaTypes)
-  const withObjectKeys = createWithObjectKeys(editorActor, schemaTypes)
+  const operationToPatches = createOperationToPatches(editorActor)
+  const withObjectKeys = createWithObjectKeys(editorActor)
   const withSchemaTypes = createWithSchemaTypes({
     editorActor,
-    schemaTypes,
   })
   const withPatches = createWithPatches({
     editorActor,
     patchFunctions: operationToPatches,
-    schemaTypes,
     subscriptions: options.subscriptions,
   })
   const withMaxBlocks = createWithMaxBlocks(editorActor)
   const withUndoRedo = createWithUndoRedo({
     editorActor,
-    blockSchemaType: schemaTypes.block,
     subscriptions: options.subscriptions,
   })
-  const withPortableTextMarkModel = createWithPortableTextMarkModel(
-    editorActor,
-    schemaTypes,
-  )
-  const withPortableTextBlockStyle = createWithPortableTextBlockStyle(
-    editorActor,
-    schemaTypes,
-  )
+  const withPortableTextMarkModel = createWithPortableTextMarkModel(editorActor)
+  const withPortableTextBlockStyle =
+    createWithPortableTextBlockStyle(editorActor)
 
   const withPlaceholderBlock = createWithPlaceholderBlock(editorActor)
 
   const withUtils = createWithUtils({
     editorActor,
-    schemaTypes,
   })
   const withPortableTextSelections =
     createWithPortableTextSelections(editorActor)

package/src/editor/range-decorations-machine.ts

@@ -17,11 +17,11 @@ import {
   type AnyEventObject,
   type CallbackLogicFunction,
 } from 'xstate'
-import type {EditorSchema} from '..'
 import {moveRangeByOperation, toSlateRange} from '../internal-utils/ranges'
 import {slateRangeToSelection} from '../internal-utils/slate-utils'
 import {isEqualToEmptyEditor} from '../internal-utils/values'
 import type {PortableTextSlateEditor, RangeDecoration} from '../types/editor'
+import type {EditorSchema} from './editor-schema'
 
 const slateOperationCallback: CallbackLogicFunction<
   AnyEventObject,

package/src/editor/sync-machine.ts

@@ -24,7 +24,7 @@ import type {
   InvalidValueResolution,
   PortableTextSlateEditor,
 } from '../types/editor'
-import type {EditorSchema} from './define-schema'
+import type {EditorSchema} from './editor-schema'
 import {withoutSaving} from './plugins/createWithUndoRedo'
 
 const debug = debugWithName('sync machine')

package/src/index.ts

@@ -11,8 +11,8 @@ export {
   defineSchema,
   type BaseDefinition,
   type SchemaDefinition,
-} from './editor/define-schema'
-export type {EditorSchema} from './editor/define-schema'
+} from './editor/editor-schema'
+export type {EditorSchema} from './editor/editor-schema'
 export {PortableTextEditable} from './editor/Editable'
 export type {PortableTextEditableProps} from './editor/Editable'
 export type {

package/src/internal-utils/__tests__/operationToPatches.test.ts

@@ -4,24 +4,26 @@ import {beforeEach, describe, expect, it} from 'vitest'
 import {createActor} from 'xstate'
 import {coreBehaviors} from '../../behaviors/behavior.core'
 import {schemaType} from '../../editor/__tests__/PortableTextEditorTester'
-import {createEditorSchema} from '../../editor/create-editor-schema'
 import {editorMachine} from '../../editor/editor-machine'
+import {legacySchemaToEditorSchema} from '../../editor/editor-schema'
 import {defaultKeyGenerator} from '../../editor/key-generator'
+import {createLegacySchema} from '../../editor/legacy-schema'
 import {withPlugins} from '../../editor/plugins/with-plugins'
 import {createOperationToPatches} from '../operationToPatches'
 
-const schemaTypes = createEditorSchema(schemaType)
+const schemaTypes = legacySchemaToEditorSchema(createLegacySchema(schemaType))
+const editorActor = createActor(editorMachine, {
+  input: {
+    behaviors: coreBehaviors,
+    schema: schemaTypes,
+    keyGenerator: defaultKeyGenerator,
+  },
+})
 
-const operationToPatches = createOperationToPatches(schemaTypes)
+const operationToPatches = createOperationToPatches(editorActor)
 
 const editor = withPlugins(createEditor(), {
-  editorActor: createActor(editorMachine, {
-    input: {
-      behaviors: coreBehaviors,
-      schema: schemaTypes,
-      keyGenerator: defaultKeyGenerator,
-    },
-  }),
+  editorActor,
   subscriptions: [],
 })
 

package/src/internal-utils/__tests__/patchToOperations.test.ts

@@ -4,14 +4,15 @@ import {beforeEach, describe, expect, it} from 'vitest'
 import {createActor} from 'xstate'
 import {coreBehaviors} from '../../behaviors/behavior.core'
 import {schemaType} from '../../editor/__tests__/PortableTextEditorTester'
-import {createEditorSchema} from '../../editor/create-editor-schema'
 import {editorMachine} from '../../editor/editor-machine'
+import {legacySchemaToEditorSchema} from '../../editor/editor-schema'
 import {defaultKeyGenerator} from '../../editor/key-generator'
+import {createLegacySchema} from '../../editor/legacy-schema'
 import {withPlugins} from '../../editor/plugins/with-plugins'
 import {createApplyPatch} from '../applyPatch'
 import {VOID_CHILD_KEY} from '../values'
 
-const schemaTypes = createEditorSchema(schemaType)
+const schemaTypes = legacySchemaToEditorSchema(createLegacySchema(schemaType))
 
 const patchToOperations = createApplyPatch(schemaTypes)
 

package/src/internal-utils/__tests__/values.test.ts

@@ -1,9 +1,10 @@
 import {describe, expect, it} from 'vitest'
 import {schemaType} from '../../editor/__tests__/PortableTextEditorTester'
-import {createEditorSchema} from '../../editor/create-editor-schema'
+import {legacySchemaToEditorSchema} from '../../editor/editor-schema'
+import {createLegacySchema} from '../../editor/legacy-schema'
 import {fromSlateValue, toSlateValue} from '../values'
 
-const schemaTypes = createEditorSchema(schemaType)
+const schemaTypes = legacySchemaToEditorSchema(createLegacySchema(schemaType))
 
 describe('toSlateValue', () => {
   it('checks undefined', () => {

package/src/internal-utils/applyPatch.ts

@@ -30,10 +30,8 @@ import {
   type Node,
   type Path as SlatePath,
 } from 'slate'
-import type {
-  PortableTextMemberSchemaTypes,
-  PortableTextSlateEditor,
-} from '../types/editor'
+import type {EditorSchema} from '../editor/editor-schema'
+import type {PortableTextSlateEditor} from '../types/editor'
 import {debugWithName} from './debug'
 import {toSlateValue} from './values'
 import {KEY_TO_SLATE_ELEMENT} from './weakMaps'
@@ -45,7 +43,7 @@ const debugVerbose = debug.enabled && true
  * Creates a function that can apply a patch onto a PortableTextSlateEditor.
  */
 export function createApplyPatch(
-  schemaTypes: PortableTextMemberSchemaTypes,
+  schema: EditorSchema,
 ): (editor: PortableTextSlateEditor, patch: Patch) => boolean {
   return (editor: PortableTextSlateEditor, patch: Patch): boolean => {
     let changed = false
@@ -61,7 +59,7 @@ export function createApplyPatch(
     try {
       switch (patch.type) {
         case 'insert':
-          changed = insertPatch(editor, patch, schemaTypes)
+          changed = insertPatch(editor, patch, schema)
           break
         case 'unset':
           changed = unsetPatch(editor, patch)
@@ -148,7 +146,7 @@ export function diffMatchPatch(
 function insertPatch(
   editor: PortableTextSlateEditor,
   patch: InsertPatch,
-  schemaTypes: PortableTextMemberSchemaTypes,
+  schema: EditorSchema,
 ) {
   const {
     block: targetBlock,
@@ -169,7 +167,7 @@ function insertPatch(
     const {items, position} = patch
     const blocksToInsert = toSlateValue(
       items as PortableTextBlock[],
-      {schemaTypes},
+      {schemaTypes: schema},
       KEY_TO_SLATE_ELEMENT.get(editor),
     ) as Descendant[]
     const targetBlockIndex = targetBlockPath[0]
@@ -191,7 +189,7 @@ function insertPatch(
     targetBlock &&
     toSlateValue(
       [{...targetBlock, children: items as PortableTextChild[]}],
-      {schemaTypes},
+      {schemaTypes: schema},
       KEY_TO_SLATE_ELEMENT.get(editor),
     )
   const targetChildIndex = targetChildPath[1]

package/src/internal-utils/create-test-snapshot.ts

@@ -1,5 +1,5 @@
 import type {EditorSnapshot} from '..'
-import {compileSchemaDefinition, defineSchema} from '../editor/define-schema'
+import {compileSchemaDefinition, defineSchema} from '../editor/editor-schema'
 import {createTestKeyGenerator} from './test-key-generator'
 
 export function createTestSnapshot(snapshot: {

package/src/internal-utils/drag-selection.test.ts

@@ -1,5 +1,5 @@
 import {describe, expect, test} from 'vitest'
-import {compileSchemaDefinition, defineSchema} from '../editor/define-schema'
+import {compileSchemaDefinition, defineSchema} from '../editor/editor-schema'
 import type {EditorSelection} from '../types/editor'
 import {createTestSnapshot} from './create-test-snapshot'
 import {getDragSelection} from './drag-selection'

package/src/internal-utils/operationToPatches.ts

@@ -21,20 +21,18 @@ import {
   type SetNodeOperation,
   type SplitNodeOperation,
 } from 'slate'
+import type {EditorActor} from '../editor/editor-machine'
 import type {PatchFunctions} from '../editor/plugins/createWithPatches'
-import type {
-  PortableTextMemberSchemaTypes,
-  PortableTextSlateEditor,
-} from '../types/editor'
+import type {PortableTextSlateEditor} from '../types/editor'
 import {debugWithName} from './debug'
 import {fromSlateValue} from './values'
 
 const debug = debugWithName('operationToPatches')
 
 export function createOperationToPatches(
-  types: PortableTextMemberSchemaTypes,
+  editorActor: EditorActor,
 ): PatchFunctions {
-  const textBlockName = types.block.name
+  const textBlockName = editorActor.getSnapshot().context.schema.block.name
   function insertTextPatch(
     editor: PortableTextSlateEditor,
     operation: InsertTextOperation,

package/src/internal-utils/parse-blocks.test.ts

@@ -1,5 +1,5 @@
 import {describe, expect, test} from 'vitest'
-import {compileSchemaDefinition, defineSchema} from '../editor/define-schema'
+import {compileSchemaDefinition, defineSchema} from '../editor/editor-schema'
 import {parseBlock, parseSpan} from './parse-blocks'
 import {createTestKeyGenerator} from './test-key-generator'
 

package/src/internal-utils/parse-blocks.ts

@@ -1,12 +1,11 @@
 import type {
-  ObjectSchemaType,
   PortableTextBlock,
   PortableTextObject,
   PortableTextSpan,
   PortableTextTextBlock,
   TypedObject,
 } from '@sanity/types'
-import type {EditorSchema} from '../editor/define-schema'
+import type {EditorSchema} from '../editor/editor-schema'
 import type {EditorContext} from '../editor/editor-snapshot'
 import {isTypedObject} from './asserters'
 
@@ -192,9 +191,9 @@ function parseTextBlock({
    */
   if (
     typeof parsedBlock.style !== 'string' ||
-    !context.schema.styles.find((style) => style.value === block.style)
+    !context.schema.styles.find((style) => style.name === block.style)
   ) {
-    const defaultStyle = context.schema.styles.at(0)?.value
+    const defaultStyle = context.schema.styles.at(0)?.name
 
     if (defaultStyle !== undefined) {
       parsedBlock.style = defaultStyle
@@ -208,7 +207,7 @@ function parseTextBlock({
    */
   if (
     typeof parsedBlock.listItem !== 'string' ||
-    !context.schema.lists.find((list) => list.value === block.listItem)
+    !context.schema.lists.find((list) => list.name === block.listItem)
   ) {
     delete parsedBlock.listItem
   }
@@ -272,7 +271,7 @@ export function parseSpan({
     }
 
     if (
-      context.schema.decorators.some((decorator) => decorator.value === mark)
+      context.schema.decorators.some((decorator) => decorator.name === mark)
     ) {
       return [mark]
     }
@@ -362,7 +361,9 @@ function parseObject({
   options,
 }: {
   object: TypedObject
-  context: Pick<EditorContext, 'keyGenerator'> & {schemaType: ObjectSchemaType}
+  context: Pick<EditorContext, 'keyGenerator'> & {
+    schemaType: EditorSchema['blockObjects'][0]
+  }
   options: {refreshKeys: boolean}
 }): PortableTextObject {
   // Validates all props on the object and only takes those that match

package/src/internal-utils/slate-children-to-blocks.ts

@@ -1,6 +1,6 @@
 import type {PortableTextBlock} from '@sanity/types'
 import type {Descendant} from 'slate'
-import type {EditorSchema} from '../editor/define-schema'
+import type {EditorSchema} from '../editor/editor-schema'
 
 export function slateChildrenToBlocks(
   schema: EditorSchema,

package/src/internal-utils/slate-utils.ts

@@ -1,5 +1,5 @@
 import {Editor, Element, Node, Range, type Path, type Point} from 'slate'
-import type {EditorSchema} from '../editor/define-schema'
+import type {EditorSchema} from '../editor/editor-schema'
 import type {EditorSelection, PortableTextSlateEditor} from '../types/editor'
 import {fromSlateValue} from './values'
 

package/src/internal-utils/validateValue.ts

@@ -6,10 +6,8 @@ import {
   type PortableTextTextBlock,
 } from '@sanity/types'
 import {flatten, isPlainObject, uniq} from 'lodash'
-import type {
-  InvalidValueResolution,
-  PortableTextMemberSchemaTypes,
-} from '../types/editor'
+import type {EditorSchema} from '../editor/editor-schema'
+import type {InvalidValueResolution} from '../types/editor'
 
 export interface Validation {
   valid: boolean
@@ -19,7 +17,7 @@ export interface Validation {
 
 export function validateValue(
   value: PortableTextBlock[] | undefined,
-  types: PortableTextMemberSchemaTypes,
+  types: EditorSchema,
   keyGenerator: () => string,
 ): Validation {
   let resolution: InvalidValueResolution | null = null
@@ -270,7 +268,7 @@ export function validateValue(
 
         // Test that every annotation mark used has a definition
         const annotationMarks = allUsedMarks.filter(
-          (mark) => !types.decorators.map((dec) => dec.value).includes(mark),
+          (mark) => !types.decorators.map((dec) => dec.name).includes(mark),
         )
         const orphanedMarks = annotationMarks.filter(
           (mark) =>

package/src/internal-utils/values.ts

@@ -7,7 +7,7 @@ import type {
 } from '@sanity/types'
 import {isEqual} from 'lodash'
 import {Element, Text, type Descendant, type Node} from 'slate'
-import type {PortableTextMemberSchemaTypes} from '../types/editor'
+import type {EditorSchema} from '../editor/editor-schema'
 
 export const EMPTY_MARKDEFS: PortableTextObject[] = []
 
@@ -31,7 +31,7 @@ function keepObjectEquality(
 
 export function toSlateValue(
   value: PortableTextBlock[] | undefined,
-  {schemaTypes}: {schemaTypes: PortableTextMemberSchemaTypes},
+  {schemaTypes}: {schemaTypes: EditorSchema},
   keyMap: Record<string, any> = {},
 ): Descendant[] {
   if (value && Array.isArray(value)) {
@@ -88,7 +88,7 @@ export function toSlateValue(
         }
         // TODO: remove this when we have a better way to handle missing style
         if (hasMissingStyle) {
-          rest.style = schemaTypes.styles[0].value
+          rest.style = schemaTypes.styles[0].name
         }
         return keepObjectEquality({_type, _key, ...rest, children}, keyMap)
       }
@@ -167,7 +167,7 @@ export function fromSlateValue(
 
 export function isEqualToEmptyEditor(
   children: Descendant[] | PortableTextBlock[],
-  schemaTypes: PortableTextMemberSchemaTypes,
+  schemaTypes: EditorSchema,
 ): boolean {
   return (
     children === undefined ||
@@ -178,7 +178,7 @@ export function isEqualToEmptyEditor(
       Element.isElement(children[0]) &&
       children[0]._type === schemaTypes.block.name &&
       'style' in children[0] &&
-      children[0].style === schemaTypes.styles[0].value &&
+      children[0].style === schemaTypes.styles[0].name &&
       !('listItem' in children[0]) &&
       Array.isArray(children[0].children) &&
       children[0].children.length === 1 &&

package/src/plugins/plugin.decorator-shortcut.ts

@@ -11,8 +11,8 @@ import {createDecoratorPairBehavior} from '../behaviors/behavior.decorator-pair'
 import {effect, execute} from '../behaviors/behavior.types.action'
 import {defineBehavior} from '../behaviors/behavior.types.behavior'
 import type {Editor} from '../editor/create-editor'
-import type {EditorSchema} from '../editor/define-schema'
 import {useEditor} from '../editor/editor-provider'
+import type {EditorSchema} from '../editor/editor-schema'
 import type {BlockOffset} from '../types/block-offset'
 import * as utils from '../utils'