@portabletext/editor 2.3.3 → 2.3.4

package/lib/utils/index.d.cts

@@ -1,5 +1,5 @@
 import { BlockOffset, BlockPath, ChildPath, EditorContext, EditorSelection, EditorSelectionPoint } from "../_chunks-dts/behavior.types.action.cjs";
-import * as _sanity_types8 from "@sanity/types";
+import * as _sanity_types9 from "@sanity/types";
 import { KeyedSegment, PortableTextBlock, PortableTextChild, PortableTextSpan, PortableTextTextBlock } from "@sanity/types";
 /**
  * @public
@@ -150,7 +150,7 @@ declare function mergeTextBlocks({
   context: Pick<EditorContext, 'keyGenerator' | 'schema'>;
   targetBlock: PortableTextTextBlock;
   incomingBlock: PortableTextTextBlock;
-}): PortableTextTextBlock<_sanity_types8.PortableTextObject | _sanity_types8.PortableTextSpan>;
+}): PortableTextTextBlock<_sanity_types9.PortableTextObject | _sanity_types9.PortableTextSpan>;
 /**
  * @public
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@portabletext/editor",
-  "version": "2.3.3",
+  "version": "2.3.4",
   "description": "Portable Text Editor made in React",
   "keywords": [
     "sanity",
@@ -79,9 +79,11 @@
     "slate-dom": "^0.117.4",
     "slate-react": "0.117.4",
     "xstate": "^5.20.2",
-    "@portabletext/block-tools": "3.0.0",
+    "@portabletext/keyboard-shortcuts": "1.1.1",
+    "@portabletext/sanity-bridge": "1.0.0",
     "@portabletext/patches": "1.1.6",
-    "@portabletext/keyboard-shortcuts": "1.1.1"
+    "@portabletext/schema": "1.0.0",
+    "@portabletext/block-tools": "3.0.0"
   },
   "devDependencies": {
     "@portabletext/toolkit": "^2.0.17",
@@ -95,8 +97,8 @@
     "@types/lodash.startcase": "^4.4.9",
     "@types/react": "^19.1.9",
     "@types/react-dom": "^19.1.7",
-    "@typescript-eslint/eslint-plugin": "^8.39.0",
-    "@typescript-eslint/parser": "^8.39.0",
+    "@typescript-eslint/eslint-plugin": "^8.39.1",
+    "@typescript-eslint/parser": "^8.39.1",
     "@vitejs/plugin-react": "^4.7.0",
     "@vitest/browser": "^3.2.4",
     "@vitest/coverage-istanbul": "^3.2.4",

package/src/converters/converter.portable-text.deserialize.test.ts

@@ -1,7 +1,9 @@
+import {
+  compileSchema,
+  defineSchema,
+  type SchemaDefinition,
+} from '@portabletext/schema'
 import {assert, describe, expect, test} from 'vitest'
-import {compileSchemaDefinition} from '../editor/editor-schema'
-import {defineSchema} from '../editor/editor-schema-definition'
-import type {SchemaDefinition} from '../editor/editor-schema-definition'
 import {createTestSnapshot} from '../internal-utils/create-test-snapshot'
 import {converterPortableText} from './converter.portable-text'
 
@@ -9,7 +11,7 @@ function createSnapshot(schema: SchemaDefinition) {
   return createTestSnapshot({
     context: {
       converters: [],
-      schema: compileSchemaDefinition(schema),
+      schema: compileSchema(schema),
     },
   })
 }

package/src/converters/converter.text-html.deserialize.test.ts

@@ -1,10 +1,10 @@
-import {describe, expect, test} from 'vitest'
+import {compileSchemaDefinitionToPortableTextMemberSchemaTypes} from '@portabletext/sanity-bridge'
 import {
-  compileSchemaDefinition,
-  compileSchemaDefinitionToLegacySchema,
-} from '../editor/editor-schema'
-import {defineSchema} from '../editor/editor-schema-definition'
-import type {SchemaDefinition} from '../editor/editor-schema-definition'
+  compileSchema,
+  defineSchema,
+  type SchemaDefinition,
+} from '@portabletext/schema'
+import {describe, expect, test} from 'vitest'
 import {createTestSnapshot} from '../internal-utils/create-test-snapshot'
 import {createConverterTextHtml} from './converter.text-html'
 
@@ -12,7 +12,7 @@ function createSnapshot(schema: SchemaDefinition) {
   return createTestSnapshot({
     context: {
       converters: [],
-      schema: compileSchemaDefinition(schema),
+      schema: compileSchema(schema),
     },
   })
 }
@@ -28,7 +28,7 @@ const nestedList = '<ol><li>foo<ul><li>bar</li></ul></li></ol>'
 describe(createConverterTextHtml.name, () => {
   test('paragraph with unknown decorators', () => {
     const converterTextHtml = createConverterTextHtml(
-      compileSchemaDefinitionToLegacySchema(defineSchema({})),
+      compileSchemaDefinitionToPortableTextMemberSchemaTypes(defineSchema({})),
     )
 
     expect(
@@ -61,7 +61,7 @@ describe(createConverterTextHtml.name, () => {
 
   test('paragraph with known decorators', () => {
     const converterTextHtml = createConverterTextHtml(
-      compileSchemaDefinitionToLegacySchema(
+      compileSchemaDefinitionToPortableTextMemberSchemaTypes(
         defineSchema({
           decorators: [{name: 'strong'}, {name: 'em'}, {name: 'code'}],
         }),
@@ -114,7 +114,7 @@ describe(createConverterTextHtml.name, () => {
 
   test('image', () => {
     const converterTextHtml = createConverterTextHtml(
-      compileSchemaDefinitionToLegacySchema(
+      compileSchemaDefinitionToPortableTextMemberSchemaTypes(
         defineSchema({
           blockObjects: [{name: 'image'}],
         }),
@@ -139,7 +139,7 @@ describe(createConverterTextHtml.name, () => {
 
   test('paragraph with unknown link', () => {
     const converterTextHtml = createConverterTextHtml(
-      compileSchemaDefinitionToLegacySchema(defineSchema({})),
+      compileSchemaDefinitionToPortableTextMemberSchemaTypes(defineSchema({})),
     )
 
     expect(
@@ -172,7 +172,7 @@ describe(createConverterTextHtml.name, () => {
 
   test('paragraph with known link', () => {
     const converterTextHtml = createConverterTextHtml(
-      compileSchemaDefinitionToLegacySchema(
+      compileSchemaDefinitionToPortableTextMemberSchemaTypes(
         defineSchema({
           annotations: [
             {name: 'link', fields: [{name: 'href', type: 'string'}]},
@@ -229,7 +229,7 @@ describe(createConverterTextHtml.name, () => {
 
   test('unordered list', () => {
     const converterTextHtml = createConverterTextHtml(
-      compileSchemaDefinitionToLegacySchema(
+      compileSchemaDefinitionToPortableTextMemberSchemaTypes(
         defineSchema({
           lists: [{name: 'bullet'}],
         }),
@@ -288,7 +288,7 @@ describe(createConverterTextHtml.name, () => {
 
   test('ordered list', () => {
     const converterTextHtml = createConverterTextHtml(
-      compileSchemaDefinitionToLegacySchema(
+      compileSchemaDefinitionToPortableTextMemberSchemaTypes(
         defineSchema({
           lists: [{name: 'number'}],
         }),
@@ -347,7 +347,7 @@ describe(createConverterTextHtml.name, () => {
 
   test('nested list', () => {
     const converterTextHtml = createConverterTextHtml(
-      compileSchemaDefinitionToLegacySchema(
+      compileSchemaDefinitionToPortableTextMemberSchemaTypes(
         defineSchema({
           lists: [{name: 'bullet'}, {name: 'number'}],
         }),

package/src/converters/converter.text-html.serialize.test.ts

@@ -1,12 +1,12 @@
+import {compileSchemaDefinitionToPortableTextMemberSchemaTypes} from '@portabletext/sanity-bridge'
+import {
+  compileSchema,
+  defineSchema,
+  type SchemaDefinition,
+} from '@portabletext/schema'
 import type {PortableTextBlock, PortableTextTextBlock} from '@sanity/types'
 import {describe, expect, test} from 'vitest'
 import type {EditorSelection} from '..'
-import {
-  compileSchemaDefinition,
-  compileSchemaDefinitionToLegacySchema,
-} from '../editor/editor-schema'
-import {defineSchema} from '../editor/editor-schema-definition'
-import type {SchemaDefinition} from '../editor/editor-schema-definition'
 import {createTestSnapshot} from '../internal-utils/create-test-snapshot'
 import {createConverterTextHtml} from './converter.text-html'
 
@@ -79,7 +79,7 @@ function createSnapshot(schema: SchemaDefinition, selection: EditorSelection) {
   return createTestSnapshot({
     context: {
       converters: [],
-      schema: compileSchemaDefinition(schema),
+      schema: compileSchema(schema),
       selection,
       value: [decoratedParagraph, image, b2, paragraphWithInlineBlock],
     },
@@ -87,7 +87,7 @@ function createSnapshot(schema: SchemaDefinition, selection: EditorSelection) {
 }
 
 const converterTextHtml = createConverterTextHtml(
-  compileSchemaDefinitionToLegacySchema(defineSchema({})),
+  compileSchemaDefinitionToPortableTextMemberSchemaTypes(defineSchema({})),
 )
 
 describe(converterTextHtml.serialize.name, () => {

package/src/converters/converter.text-plain.test.ts

@@ -1,13 +1,13 @@
+import {compileSchemaDefinitionToPortableTextMemberSchemaTypes} from '@portabletext/sanity-bridge'
+import {
+  compileSchema,
+  defineSchema,
+  type SchemaDefinition,
+} from '@portabletext/schema'
 import type {PortableTextBlock, PortableTextTextBlock} from '@sanity/types'
 import {expect, test} from 'vitest'
 import type {EditorSelection} from '..'
 import {schemaDefinition} from '../editor/__tests__/PortableTextEditorTester'
-import {
-  compileSchemaDefinition,
-  compileSchemaDefinitionToLegacySchema,
-} from '../editor/editor-schema'
-import type {SchemaDefinition} from '../editor/editor-schema-definition'
-import {defineSchema} from '../editor/editor-schema-definition'
 import {createTestSnapshot} from '../internal-utils/create-test-snapshot'
 import {createConverterTextPlain} from './converter.text-plain'
 
@@ -76,7 +76,7 @@ function createSnapshot({
   return createTestSnapshot({
     context: {
       converters: [],
-      schema: compileSchemaDefinition(schema),
+      schema: compileSchema(schema),
       selection,
       value: [b1, b2, b3, b4],
     },
@@ -84,7 +84,7 @@ function createSnapshot({
 }
 
 const converterTextPlain = createConverterTextPlain(
-  compileSchemaDefinitionToLegacySchema(schemaDefinition),
+  compileSchemaDefinitionToPortableTextMemberSchemaTypes(schemaDefinition),
 )
 
 test(converterTextPlain.serialize.name, () => {

package/src/editor/create-editor.ts

@@ -1,3 +1,9 @@
+import {
+  compileSchemaDefinitionToPortableTextMemberSchemaTypes,
+  createPortableTextMemberSchemaTypes,
+  portableTextMemberSchemaTypesToSchema,
+} from '@portabletext/sanity-bridge'
+import {compileSchema} from '@portabletext/schema'
 import {createActor} from 'xstate'
 import {createCoreConverters} from '../converters/converters.core'
 import type {Editor, EditorConfig} from '../editor'
@@ -12,14 +18,8 @@ import {createSlateEditor, type SlateEditor} from './create-slate-editor'
 import {createEditorDom} from './editor-dom'
 import type {EditorActor} from './editor-machine'
 import {editorMachine} from './editor-machine'
-import {
-  compileSchemaDefinition,
-  compileSchemaDefinitionToLegacySchema,
-  legacySchemaToEditorSchema,
-} from './editor-schema'
 import {getEditorSnapshot} from './editor-selector'
 import {defaultKeyGenerator} from './key-generator'
-import {createLegacySchema} from './legacy-schema'
 import {mutationMachine, type MutationActor} from './mutation-machine'
 import {createEditableAPI} from './plugins/createWithEditableAPI'
 import {relayMachine, type RelayActor} from './relay-machine'
@@ -206,15 +206,17 @@ function editorConfigToMachineInput(config: EditorConfig) {
 
 function compileSchemasFromEditorConfig(config: EditorConfig) {
   const legacySchema = config.schemaDefinition
-    ? compileSchemaDefinitionToLegacySchema(config.schemaDefinition)
-    : createLegacySchema(
+    ? compileSchemaDefinitionToPortableTextMemberSchemaTypes(
+        config.schemaDefinition,
+      )
+    : createPortableTextMemberSchemaTypes(
         config.schema.hasOwnProperty('jsonType')
           ? config.schema
           : compileType(config.schema),
       )
   const schema = config.schemaDefinition
-    ? compileSchemaDefinition(config.schemaDefinition)
-    : legacySchemaToEditorSchema(legacySchema)
+    ? compileSchema(config.schemaDefinition)
+    : portableTextMemberSchemaTypesToSchema(legacySchema)
 
   return {
     legacySchema,

package/src/editor/editor-schema.ts

@@ -1,316 +1,6 @@
-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 type {
-  BaseDefinition,
-  FieldDefinition,
-  SchemaDefinition,
-} from './editor-schema-definition'
-import {defaultKeyGenerator} from './key-generator'
-import {createLegacySchema} from './legacy-schema'
-
-const temporaryImageName = `tmp-${defaultKeyGenerator()}-image`
-const temporaryUrlName = `tmp-${defaultKeyGenerator()}-url`
-
-const temporaryObjectNames: Record<string, string> = {
-  image: temporaryImageName,
-  url: temporaryUrlName,
-}
-
-const objectNames: Record<string, string> = {
-  [temporaryImageName]: 'image',
-  [temporaryUrlName]: 'url',
-}
-
-const defaultObjectTitles: Record<string, string> = {
-  image: 'Image',
-  url: 'URL',
-}
-
-/**
- * @public
- */
-export type EditorSchema = {
-  annotations: ReadonlyArray<AnnotationSchemaType>
-  block: {
-    name: string
-  }
-  blockObjects: ReadonlyArray<BlockObjectSchemaType>
-  decorators: ReadonlyArray<DecoratorSchemaType>
-  inlineObjects: ReadonlyArray<InlineObjectSchemaType>
-  span: {
-    name: string
-  }
-  styles: ReadonlyArray<StyleSchemaType>
-  lists: ReadonlyArray<ListSchemaType>
-}
-
-/**
- * @public
- */
-export type AnnotationSchemaType = BaseDefinition & {
-  fields: ReadonlyArray<FieldDefinition>
-}
-
-/**
- * @public
- */
-export type BlockObjectSchemaType = BaseDefinition & {
-  fields: ReadonlyArray<FieldDefinition>
-}
-
-/**
- * @public
- */
-export type DecoratorSchemaType = BaseDefinition & {
-  /**
-   * @deprecated
-   * Use `name` instead
-   */
-  value: string
-}
-
-/**
- * @public
- */
-export type InlineObjectSchemaType = BaseDefinition & {
-  fields: ReadonlyArray<FieldDefinition>
-}
+import type {Schema} from '@portabletext/schema'
 
 /**
  * @public
  */
-export type ListSchemaType = BaseDefinition & {
-  /**
-   * @deprecated
-   * Use `name` instead
-   */
-  value: string
-}
-
-/**
- * @public
- */
-export type StyleSchemaType = 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: field.type.title,
-      })),
-      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: field.type.title,
-      })),
-      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: field.type.title,
-      })),
-      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): EditorSchema {
-  const styles = (definition.styles ?? []).map((style) => ({
-    ...style,
-    value: style.name,
-  }))
-
-  return {
-    block: {
-      name: 'block',
-    },
-    span: {
-      name: 'span',
-    },
-    styles: !styles.some((style) => style.value === 'normal')
-      ? [{value: 'normal', name: 'normal', title: 'Normal'}, ...styles]
-      : styles,
-    lists: (definition.lists ?? []).map((list) => ({
-      ...list,
-      value: list.name,
-    })),
-    decorators: (definition.decorators ?? []).map((decorator) => ({
-      ...decorator,
-      value: decorator.name,
-    })),
-    annotations: (definition.annotations ?? []).map((annotation) => ({
-      ...annotation,
-      fields: annotation.fields ?? [],
-    })),
-    blockObjects: (definition.blockObjects ?? []).map((blockObject) => ({
-      ...blockObject,
-      fields: blockObject.fields ?? [],
-    })),
-    inlineObjects: (definition.inlineObjects ?? []).map((inlineObject) => ({
-      ...inlineObject,
-      fields: inlineObject.fields ?? [],
-    })),
-  }
-}
-
-export function compileSchemaDefinitionToLegacySchema<
-  TSchemaDefinition extends SchemaDefinition,
->(definition?: TSchemaDefinition): PortableTextMemberSchemaTypes {
-  const blockObjects =
-    definition?.blockObjects?.map((blockObject) =>
-      defineType({
-        type: 'object',
-        // Very naive way to work around `SanitySchema.compile` adding default
-        // fields to objects with certain names.
-        name: temporaryObjectNames[blockObject.name] ?? blockObject.name,
-        title:
-          blockObject.title === undefined
-            ? // This avoids the default title which is a title case of the object name
-              defaultObjectTitles[blockObject.name]
-            : blockObject.title,
-        fields:
-          blockObject.fields?.map((field) => ({
-            name: field.name,
-            type: field.type,
-            title: field.title ?? startCase(field.name),
-          })) ?? [],
-      }),
-    ) ?? []
-
-  const inlineObjects =
-    definition?.inlineObjects?.map((inlineObject) =>
-      defineType({
-        type: 'object',
-        // Very naive way to work around `SanitySchema.compile` adding default
-        // fields to objects with certain names.
-        name: temporaryObjectNames[inlineObject.name] ?? inlineObject.name,
-
-        title:
-          inlineObject.title === undefined
-            ? // This avoids the default title which is a title case of the object name
-              defaultObjectTitles[inlineObject.name]
-            : inlineObject.title,
-        fields:
-          inlineObject.fields?.map((field) => ({
-            name: field.name,
-            type: field.type,
-            title: field.title ?? startCase(field.name),
-          })) ?? [],
-      }),
-    ) ?? []
-
-  const portableTextSchema = defineField({
-    type: 'array',
-    name: 'portable-text',
-    of: [
-      ...blockObjects.map((blockObject) => ({type: blockObject.name})),
-      {
-        type: 'block',
-        name: 'block',
-        of: inlineObjects.map((inlineObject) => ({type: inlineObject.name})),
-        marks: {
-          decorators:
-            definition?.decorators?.map((decorator) => ({
-              title: decorator.title ?? startCase(decorator.name),
-              value: decorator.name,
-            })) ?? [],
-          annotations:
-            definition?.annotations?.map((annotation) => ({
-              name: annotation.name,
-              type: 'object',
-              title: annotation.title,
-              fields:
-                annotation.fields?.map((field) => ({
-                  name: field.name,
-                  title: field.title ?? startCase(field.name),
-                  type: field.type,
-                })) ?? [],
-            })) ?? [],
-        },
-        lists:
-          definition?.lists?.map((list) => ({
-            value: list.name,
-            title: list.title ?? startCase(list.name),
-          })) ?? [],
-        styles:
-          definition?.styles?.map((style) => ({
-            value: style.name,
-            title: style.title ?? startCase(style.name),
-          })) ?? [],
-      },
-    ],
-  })
-
-  const schema = SanitySchema.compile({
-    types: [portableTextSchema, ...blockObjects, ...inlineObjects],
-  }).get('portable-text')
-
-  const pteSchema = createLegacySchema(schema)
-
-  return {
-    ...pteSchema,
-    blockObjects: pteSchema.blockObjects.map((blockObject) =>
-      objectNames[blockObject.name] !== undefined
-        ? ({
-            ...blockObject,
-            name: objectNames[blockObject.name],
-            type: {
-              ...blockObject.type,
-              name: objectNames[blockObject.name],
-            },
-          } as ObjectSchemaType)
-        : blockObject,
-    ),
-    inlineObjects: pteSchema.inlineObjects.map((inlineObject) =>
-      objectNames[inlineObject.name] !== undefined
-        ? ({
-            ...inlineObject,
-            name: objectNames[inlineObject.name],
-          } as ObjectSchemaType)
-        : inlineObject,
-    ),
-  } satisfies PortableTextMemberSchemaTypes
-}
+export type EditorSchema = Schema

package/src/editor/plugins/__tests__/withEditableAPIGetFragment.test.tsx

@@ -1,3 +1,4 @@
+import {compileSchema} from '@portabletext/schema'
 import {render, waitFor} from '@testing-library/react'
 import {createRef, type RefObject} from 'react'
 import {describe, expect, it, vi} from 'vitest'
@@ -7,7 +8,6 @@ import {
 } from '../../__tests__/PortableTextEditorTester'
 import {isTextBlock} from '../../../internal-utils/parse-blocks'
 import {createTestKeyGenerator} from '../../../internal-utils/test-key-generator'
-import {compileSchemaDefinition} from '../../editor-schema'
 import {PortableTextEditor} from '../../PortableTextEditor'
 
 const initialValue = [
@@ -88,7 +88,7 @@ describe('plugin:withEditableAPI: .getFragment()', () => {
           fragment &&
             isTextBlock(
               {
-                schema: compileSchemaDefinition(schemaDefinition),
+                schema: compileSchema(schemaDefinition),
               },
               fragment[0],
             ) &&

package/src/editor.ts

@@ -1,3 +1,4 @@
+import type {SchemaDefinition} from '@portabletext/schema'
 import type {
   ArrayDefinition,
   ArraySchemaType,
@@ -8,7 +9,6 @@ import type {Behavior} from './behaviors/behavior.types.behavior'
 import type {ExternalBehaviorEvent} from './behaviors/behavior.types.event'
 import type {EditorDom} from './editor/editor-dom'
 import type {ExternalEditorEvent} from './editor/editor-machine'
-import type {SchemaDefinition} from './editor/editor-schema-definition'
 import type {EditorSnapshot} from './editor/editor-snapshot'
 import type {EditorEmittedEvent} from './editor/relay-machine'
 

package/src/index.ts

@@ -19,11 +19,11 @@ export type {
   AnnotationSchemaType,
   BlockObjectSchemaType,
   DecoratorSchemaType,
-  EditorSchema,
   InlineObjectSchemaType,
   ListSchemaType,
   StyleSchemaType,
-} from './editor/editor-schema'
+} from '@portabletext/schema'
+export type {EditorSchema} from './editor/editor-schema'
 export {
   defineSchema,
   type AnnotationDefinition,
@@ -35,7 +35,7 @@ export {
   type ListDefinition,
   type SchemaDefinition,
   type StyleDefinition,
-} from './editor/editor-schema-definition'
+} from '@portabletext/schema'
 export {useEditorSelector, type EditorSelector} from './editor/editor-selector'
 export type {EditorContext, EditorSnapshot} from './editor/editor-snapshot'
 export {usePortableTextEditor} from './editor/hooks/usePortableTextEditor'

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

@@ -1,9 +1,8 @@
+import {compileSchema, defineSchema} from '@portabletext/schema'
 import {describe, expect, it} from 'vitest'
-import {compileSchemaDefinition} from '../../editor/editor-schema'
-import {defineSchema} from '../../editor/editor-schema-definition'
 import {fromSlateValue, toSlateValue} from '../values'
 
-const schemaTypes = compileSchemaDefinition(defineSchema({}))
+const schemaTypes = compileSchema(defineSchema({}))
 
 describe('toSlateValue', () => {
   it('checks undefined', () => {