@portabletext/editor 1.47.0 → 1.47.2

package/src/editor/editor-machine.ts

@@ -21,7 +21,7 @@ import type {
   InvalidValueResolution,
   PortableTextSlateEditor,
 } from '../types/editor'
-import type {EditorSchema} from './define-schema'
+import type {EditorSchema} from './editor-schema'
 import {createEditorSnapshot} from './editor-snapshot'
 
 export * from 'xstate/guards'

package/src/editor/{define-schema.ts → editor-schema.ts}

@@ -2,8 +2,8 @@ import {Schema as SanitySchema} from '@sanity/schema'
 import {defineField, defineType, type ObjectSchemaType} from '@sanity/types'
 import startCase from 'lodash.startcase'
 import type {PortableTextMemberSchemaTypes} from '../types/editor'
-import {createEditorSchema} from './create-editor-schema'
 import {defaultKeyGenerator} from './key-generator'
+import {createLegacySchema} from './legacy-schema'
 
 /**
  * @public
@@ -88,11 +88,120 @@ const defaultObjectTitles: Record<string, string> = {
 /**
  * @public
  */
-export type EditorSchema = PortableTextMemberSchemaTypes
+export type EditorSchema = {
+  annotations: ReadonlyArray<
+    BaseDefinition & {
+      fields: ReadonlyArray<{name: string; type: string}>
+    }
+  >
+  block: {
+    name: string
+  }
+  blockObjects: ReadonlyArray<
+    BaseDefinition & {
+      fields: ReadonlyArray<{name: string; type: string}>
+    }
+  >
+  decorators: ReadonlyArray<
+    BaseDefinition & {
+      /**
+       * @deprecated
+       * Use `name` instead
+       */
+      value: string
+    }
+  >
+  inlineObjects: ReadonlyArray<
+    BaseDefinition & {
+      fields: ReadonlyArray<{name: string; type: string}>
+    }
+  >
+  span: {
+    name: string
+  }
+  styles: ReadonlyArray<
+    BaseDefinition & {
+      /**
+       * @deprecated
+       * Use `name` instead
+       */
+      value: string
+    }
+  >
+  lists: ReadonlyArray<
+    BaseDefinition & {
+      /**
+       * @deprecated
+       * Use `name` instead
+       */
+      value: string
+    }
+  >
+}
+
+export function legacySchemaToEditorSchema(
+  schema: PortableTextMemberSchemaTypes,
+): EditorSchema {
+  return {
+    annotations: schema.annotations.map((annotation) => ({
+      name: annotation.name,
+      fields: annotation.fields.map((field) => ({
+        name: field.name,
+        type: field.type.jsonType,
+      })),
+      title: annotation.title,
+    })),
+    block: {
+      name: schema.block.name,
+    },
+    blockObjects: schema.blockObjects.map((blockObject) => ({
+      name: blockObject.name,
+      fields: blockObject.fields.map((field) => ({
+        name: field.name,
+        type: field.type.jsonType,
+      })),
+      title: blockObject.title,
+    })),
+    decorators: schema.decorators.map((decorator) => ({
+      name: decorator.value,
+      title: decorator.title,
+      value: decorator.value,
+    })),
+    inlineObjects: schema.inlineObjects.map((inlineObject) => ({
+      name: inlineObject.name,
+      fields: inlineObject.fields.map((field) => ({
+        name: field.name,
+        type: field.type.jsonType,
+      })),
+      title: inlineObject.title,
+    })),
+    span: {
+      name: schema.span.name,
+    },
+    styles: schema.styles.map((style) => ({
+      name: style.value,
+      title: style.title,
+      value: style.value,
+    })),
+    lists: schema.lists.map((list) => ({
+      name: list.value,
+      title: list.title,
+      value: list.value,
+    })),
+  }
+}
 
 export function compileSchemaDefinition<
   TSchemaDefinition extends SchemaDefinition,
->(definition?: TSchemaDefinition) {
+>(definition: TSchemaDefinition): EditorSchema {
+  return legacySchemaToEditorSchema(
+    compileSchemaDefinitionToLegacySchema(definition),
+  )
+}
+
+export function compileSchemaDefinitionToLegacySchema<
+  TSchemaDefinition extends SchemaDefinition,
+>(definition?: TSchemaDefinition): PortableTextMemberSchemaTypes {
   const blockObjects =
     definition?.blockObjects?.map((blockObject) =>
       defineType({
@@ -179,7 +288,7 @@ export function compileSchemaDefinition<
     types: [portableTextSchema, ...blockObjects, ...inlineObjects],
   }).get('portable-text')
 
-  const pteSchema = createEditorSchema(schema)
+  const pteSchema = createLegacySchema(schema)
 
   return {
     ...pteSchema,
@@ -203,5 +312,5 @@ export function compileSchemaDefinition<
           } as ObjectSchemaType)
         : inlineObject,
     ),
-  } satisfies EditorSchema
+  } satisfies PortableTextMemberSchemaTypes
 }

package/src/editor/editor-snapshot.ts

@@ -4,8 +4,8 @@ import type {EventPosition} from '../internal-utils/event-position'
 import {slateChildrenToBlocks} from '../internal-utils/slate-children-to-blocks'
 import {slateRangeToSelection} from '../internal-utils/slate-utils'
 import type {EditorSelection, PortableTextSlateEditor} from '../types/editor'
-import type {EditorSchema} from './define-schema'
 import type {HasTag} from './editor-machine'
+import type {EditorSchema} from './editor-schema'
 import {getActiveDecorators} from './get-active-decorators'
 
 /**

package/src/editor/get-active-decorators.ts

@@ -1,6 +1,6 @@
 import {Editor} from 'slate'
 import type {PortableTextSlateEditor} from '../types/editor'
-import type {EditorSchema} from './define-schema'
+import type {EditorSchema} from './editor-schema'
 
 export function getActiveDecorators({
   schema,
@@ -9,7 +9,7 @@ export function getActiveDecorators({
   schema: EditorSchema
   slateEditorInstance: PortableTextSlateEditor
 }) {
-  const decorators = schema.decorators.map((decorator) => decorator.value)
+  const decorators = schema.decorators.map((decorator) => decorator.name)
 
   const marks =
     {

package/src/editor/{create-editor-schema.ts → legacy-schema.ts}

@@ -6,11 +6,11 @@ import type {
   SchemaType,
   SpanSchemaType,
 } from '@sanity/types'
-import type {EditorSchema} from './define-schema'
+import type {PortableTextMemberSchemaTypes} from '../types/editor'
 
-export function createEditorSchema(
+export function createLegacySchema(
   portableTextType: ArraySchemaType<PortableTextBlock>,
-): EditorSchema {
+): PortableTextMemberSchemaTypes {
   if (!portableTextType) {
     throw new Error("Parameter 'portabletextType' missing (required)")
   }

package/src/editor/mutation-machine.ts

@@ -14,7 +14,7 @@ import {
   type AnyEventObject,
 } from 'xstate'
 import type {PortableTextSlateEditor} from '../types/editor'
-import type {EditorSchema} from './define-schema'
+import type {EditorSchema} from './editor-schema'
 
 /**
  * Makes sure editor mutation events are debounced

package/src/editor/plugins/createWithObjectKeys.ts

@@ -1,20 +1,14 @@
 import {Editor, Element, Node, Transforms} from 'slate'
 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'
 
 /**
  * This plugin makes sure that every new node in the editor get a new _key prop when created
  *
  */
-export function createWithObjectKeys(
-  editorActor: EditorActor,
-  schemaTypes: PortableTextMemberSchemaTypes,
-) {
+export function createWithObjectKeys(editorActor: EditorActor) {
   return function withKeys(
     editor: PortableTextSlateEditor,
   ): PortableTextSlateEditor {
@@ -89,7 +83,10 @@ export function createWithObjectKeys(
 
     editor.normalizeNode = (entry) => {
       const [node, path] = entry
-      if (Element.isElement(node) && node._type === schemaTypes.block.name) {
+      if (
+        Element.isElement(node) &&
+        node._type === editorActor.getSnapshot().context.schema.block.name
+      ) {
         // Set key on block itself
         if (!node._key) {
           editorActor.send({type: 'normalizing'})

package/src/editor/plugins/createWithPatches.ts

@@ -25,10 +25,7 @@ import {
   PATCHING,
   withoutPatching,
 } from '../../internal-utils/withoutPatching'
-import type {
-  PortableTextMemberSchemaTypes,
-  PortableTextSlateEditor,
-} from '../../types/editor'
+import type {PortableTextSlateEditor} from '../../types/editor'
 import type {EditorActor} from '../editor-machine'
 import {getCurrentActionId} from '../with-applying-behavior-actions'
 import {withoutSaving} from './createWithUndoRedo'
@@ -82,21 +79,19 @@ export interface PatchFunctions {
 interface Options {
   editorActor: EditorActor
   patchFunctions: PatchFunctions
-  schemaTypes: PortableTextMemberSchemaTypes
   subscriptions: Array<() => () => void>
 }
 
 export function createWithPatches({
   editorActor,
   patchFunctions,
-  schemaTypes,
   subscriptions,
 }: Options): (editor: PortableTextSlateEditor) => PortableTextSlateEditor {
   // The previous editor children are needed to figure out the _key of deleted nodes
   // The editor.children would no longer contain that information if the node is already deleted.
   let previousChildren: Descendant[]
 
-  const applyPatch = createApplyPatch(schemaTypes)
+  const applyPatch = createApplyPatch(editorActor.getSnapshot().context.schema)
 
   return function withPatches(editor: PortableTextSlateEditor) {
     IS_PROCESSING_REMOTE_CHANGES.set(editor, false)
@@ -156,12 +151,18 @@ export function createWithPatches({
       // Update previous children here before we apply
       previousChildren = editor.children
 
-      const editorWasEmpty = isEqualToEmptyEditor(previousChildren, schemaTypes)
+      const editorWasEmpty = isEqualToEmptyEditor(
+        previousChildren,
+        editorActor.getSnapshot().context.schema,
+      )
 
       // Apply the operation
       apply(operation)
 
-      const editorIsEmpty = isEqualToEmptyEditor(editor.children, schemaTypes)
+      const editorIsEmpty = isEqualToEmptyEditor(
+        editor.children,
+        editorActor.getSnapshot().context.schema,
+      )
 
       if (!isPatching(editor)) {
         if (debugVerbose && debug.enabled)
@@ -275,7 +276,7 @@ export function createWithPatches({
           type: 'notify.unset',
           previousValue: fromSlateValue(
             previousChildren,
-            schemaTypes.block.name,
+            editorActor.getSnapshot().context.schema.block.name,
             KEY_TO_VALUE_ELEMENT.get(editor),
           ),
         })
@@ -295,7 +296,7 @@ export function createWithPatches({
             actionId: getCurrentActionId(editor),
             value: fromSlateValue(
               editor.children,
-              schemaTypes.block.name,
+              editorActor.getSnapshot().context.schema.block.name,
               KEY_TO_VALUE_ELEMENT.get(editor),
             ),
           })

package/src/editor/plugins/createWithPortableTextBlockStyle.ts

@@ -1,18 +1,14 @@
 import {Editor, Path, Text as SlateText, Transforms} 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:withPortableTextBlockStyle')
 
 export function createWithPortableTextBlockStyle(
   editorActor: EditorActor,
-  types: PortableTextMemberSchemaTypes,
 ): (editor: PortableTextSlateEditor) => PortableTextSlateEditor {
-  const defaultStyle = types.styles[0].value
+  const defaultStyle = editorActor.getSnapshot().context.schema.styles[0].name
   return function withPortableTextBlockStyle(
     editor: PortableTextSlateEditor,
   ): PortableTextSlateEditor {

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 {