@portabletext/editor 1.47.0 → 1.47.2

package/lib/_chunks-es/editor-provider.js

@@ -1,6 +1,6 @@
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import { c } from "react-compiler-runtime";
-import React, { useEffect, createContext, useContext, useState, startTransition, Component } from "react";
+import React, { useEffect, useMemo, createContext, useContext, useState, startTransition, Component } from "react";
 import { ReactEditor, withReact, Slate } from "slate-react";
 import { useSelector, useActorRef } from "@xstate/react";
 import debug$g from "debug";
@@ -25,9 +25,9 @@ import omit from "lodash/omit.js";
 import { selectionPointToBlockOffset, blockOffsetsToSelection } from "./util.selection-point-to-block-offset.js";
 import { getTrimmedSelection, isActiveAnnotation, isActiveDecorator, getSelectedTextBlocks, isActiveListItem, isActiveStyle, isSelectingEntireBlocks, getActiveAnnotations } from "./selector.is-selecting-entire-blocks.js";
 import { DOMEditor } from "slate-dom";
-import startCase from "lodash.startcase";
 import { defineBehavior, raise, coreBehaviors } from "./behavior.core.js";
 import { getFocusTextBlock, getPreviousBlock, getNextBlock, getFocusSpan, isSelectionCollapsed, isOverlappingSelection, getSelectedBlocks, isSelectionExpanded } from "./selector.is-overlapping-selection.js";
+import startCase from "lodash.startcase";
 import { Subject } from "rxjs";
 import { useEffectEvent } from "use-effect-event";
 const rootName = "sanity-pte:";
@@ -72,7 +72,7 @@ function toSlateValue(value, {
           __inline: !0
         }, keyMap)) : child;
       });
-      return !hasMissingStyle && !hasMissingMarkDefs && !hasMissingChildren && !hasInlines && Element.isElement(block) ? block : (hasMissingStyle && (rest.style = schemaTypes.styles[0].value), keepObjectEquality({
+      return !hasMissingStyle && !hasMissingMarkDefs && !hasMissingChildren && !hasInlines && Element.isElement(block) ? block : (hasMissingStyle && (rest.style = schemaTypes.styles[0].name), keepObjectEquality({
         _type,
         _key,
         ...rest,
@@ -141,7 +141,7 @@ function fromSlateValue(value, textBlockType, keyMap = {}) {
   });
 }
 function isEqualToEmptyEditor(children, schemaTypes) {
-  return children === void 0 || children && Array.isArray(children) && children.length === 0 || children && Array.isArray(children) && children.length === 1 && Element.isElement(children[0]) && children[0]._type === schemaTypes.block.name && "style" in children[0] && children[0].style === schemaTypes.styles[0].value && !("listItem" in children[0]) && Array.isArray(children[0].children) && children[0].children.length === 1 && Text.isText(children[0].children[0]) && children[0].children[0]._type === "span" && !children[0].children[0].marks?.join("") && children[0].children[0].text === "";
+  return children === void 0 || children && Array.isArray(children) && children.length === 0 || children && Array.isArray(children) && children.length === 1 && Element.isElement(children[0]) && children[0]._type === schemaTypes.block.name && "style" in children[0] && children[0].style === schemaTypes.styles[0].name && !("listItem" in children[0]) && Array.isArray(children[0].children) && children[0].children.length === 1 && Text.isText(children[0].children[0]) && children[0].children[0]._type === "span" && !children[0].children[0].marks?.join("") && children[0].children[0].text === "";
 }
 const IS_PROCESSING_REMOTE_CHANGES = /* @__PURE__ */ new WeakMap(), KEY_TO_SLATE_ELEMENT = /* @__PURE__ */ new WeakMap(), KEY_TO_VALUE_ELEMENT = /* @__PURE__ */ new WeakMap(), SLATE_TO_PORTABLE_TEXT_RANGE = /* @__PURE__ */ new WeakMap(), mutationMachine = setup({
   types: {
@@ -502,7 +502,7 @@ function validateValue(value, types, keyGenerator) {
             }
           }, !0;
       }
-      const orphanedMarks = allUsedMarks.filter((mark) => !types.decorators.map((dec) => dec.value).includes(mark)).filter((mark) => textBlock.markDefs === void 0 || !textBlock.markDefs.find((def) => def._key === mark));
+      const orphanedMarks = allUsedMarks.filter((mark) => !types.decorators.map((dec) => dec.name).includes(mark)).filter((mark) => textBlock.markDefs === void 0 || !textBlock.markDefs.find((def) => def._key === mark));
       if (orphanedMarks.length > 0) {
         const spanChildren = textBlock.children.filter((cld) => cld._type === types.span.name && Array.isArray(cld.marks) && cld.marks.some((mark) => orphanedMarks.includes(mark)));
         if (spanChildren) {
@@ -1355,11 +1355,10 @@ const debug$f = debugWithName("plugin:withUndoRedo"), SAVING = /* @__PURE__ */ n
 }, getRemotePatches = (editor) => (REMOTE_PATCHES.get(editor) || REMOTE_PATCHES.set(editor, []), REMOTE_PATCHES.get(editor) || []);
 function createWithUndoRedo(options) {
   const {
-    editorActor,
-    blockSchemaType
+    editorActor
   } = options;
   return (editor) => {
-    let previousSnapshot = fromSlateValue(editor.children, blockSchemaType.name);
+    let previousSnapshot = fromSlateValue(editor.children, editorActor.getSnapshot().context.schema.block.name);
     const remotePatches = getRemotePatches(editor);
     let previousBehaviorActionSetId = getCurrentBehaviorActionSetId(editor);
     options.subscriptions.push(() => {
@@ -2085,7 +2084,7 @@ function Synchronizer(props) {
   }, $[6] = slateEditor, $[7] = t0.context.keyGenerator, $[8] = t2, $[9] = t3.context.schema, $[10] = t4) : t4 = $[10];
   const syncActorRef = useActorRef(syncMachine, t4);
   let t5;
-  $[11] !== editorActor ? (t5 = editorActor.getSnapshot(), $[11] = editorActor, $[12] = t5) : t5 = $[12];
+  $[11] !== props.editorActor ? (t5 = props.editorActor.getSnapshot(), $[11] = props.editorActor, $[12] = t5) : t5 = $[12];
   let t6;
   $[13] !== slateEditor || $[14] !== t5.context.schema ? (t6 = {
     input: {
@@ -2288,121 +2287,128 @@ const converterJson = {
       mimeType: "application/x-portable-text"
     };
   }
-}, converterTextHtml = {
-  mimeType: "text/html",
-  serialize: ({
-    snapshot,
-    event
-  }) => {
-    const selection = snapshot.beta.internalDrag?.origin.selection ?? snapshot.context.selection;
-    if (!selection)
-      return {
+};
+function createConverterTextHtml(legacySchema) {
+  return {
+    mimeType: "text/html",
+    serialize: ({
+      snapshot,
+      event
+    }) => {
+      const selection = snapshot.beta.internalDrag?.origin.selection ?? snapshot.context.selection;
+      if (!selection)
+        return {
+          type: "serialization.failure",
+          mimeType: "text/html",
+          originEvent: event.originEvent,
+          reason: "No selection"
+        };
+      const blocks = sliceBlocks({
+        blocks: snapshot.context.value,
+        selection
+      }), html = toHTML(blocks, {
+        onMissingComponent: !1,
+        components: {
+          unknownType: ({
+            children
+          }) => children !== void 0 ? `${children}` : ""
+        }
+      });
+      return html === "" ? {
         type: "serialization.failure",
         mimeType: "text/html",
         originEvent: event.originEvent,
-        reason: "No selection"
+        reason: "Serialized HTML is empty"
+      } : {
+        type: "serialization.success",
+        data: html,
+        mimeType: "text/html",
+        originEvent: event.originEvent
       };
-    const blocks = sliceBlocks({
-      blocks: snapshot.context.value,
-      selection
-    }), html = toHTML(blocks, {
-      onMissingComponent: !1,
-      components: {
-        unknownType: ({
-          children
-        }) => children !== void 0 ? `${children}` : ""
-      }
-    });
-    return html === "" ? {
-      type: "serialization.failure",
-      mimeType: "text/html",
-      originEvent: event.originEvent,
-      reason: "Serialized HTML is empty"
-    } : {
-      type: "serialization.success",
-      data: html,
-      mimeType: "text/html",
-      originEvent: event.originEvent
-    };
-  },
-  deserialize: ({
-    snapshot,
-    event
-  }) => {
-    const parsedBlocks = htmlToBlocks(event.data, snapshot.context.schema.portableText, {
-      keyGenerator: snapshot.context.keyGenerator,
-      unstable_whitespaceOnPasteMode: snapshot.context.schema.block.options.unstable_whitespaceOnPasteMode
-    }).flatMap((block) => {
-      const parsedBlock = parseBlock({
-        context: snapshot.context,
-        block,
-        options: {
-          refreshKeys: !1
-        }
+    },
+    deserialize: ({
+      snapshot,
+      event
+    }) => {
+      const parsedBlocks = htmlToBlocks(event.data, legacySchema.portableText, {
+        keyGenerator: snapshot.context.keyGenerator,
+        unstable_whitespaceOnPasteMode: legacySchema.block.options.unstable_whitespaceOnPasteMode
+      }).flatMap((block) => {
+        const parsedBlock = parseBlock({
+          context: snapshot.context,
+          block,
+          options: {
+            refreshKeys: !1
+          }
+        });
+        return parsedBlock ? [parsedBlock] : [];
       });
-      return parsedBlock ? [parsedBlock] : [];
-    });
-    return parsedBlocks.length === 0 ? {
-      type: "deserialization.failure",
-      mimeType: "text/html",
-      reason: "No blocks deserialized"
-    } : {
-      type: "deserialization.success",
-      data: parsedBlocks,
-      mimeType: "text/html"
-    };
-  }
-}, converterTextPlain = {
-  mimeType: "text/plain",
-  serialize: ({
-    snapshot,
-    event
-  }) => {
-    const selection = snapshot.beta.internalDrag?.origin.selection ?? snapshot.context.selection;
-    return selection ? {
-      type: "serialization.success",
-      data: sliceBlocks({
-        blocks: snapshot.context.value,
-        selection
-      }).map((block) => isPortableTextTextBlock(block) ? block.children.map((child) => child._type === snapshot.context.schema.span.name ? child.text : snapshot.beta.hasTag("dragging internally") ? `[${snapshot.context.schema.inlineObjects.find((inlineObjectType) => inlineObjectType.name === child._type)?.title ?? "Object"}]` : "").join("") : snapshot.beta.hasTag("dragging internally") ? `[${snapshot.context.schema.blockObjects.find((blockObjectType) => blockObjectType.name === block._type)?.title ?? "Object"}]` : "").filter((block) => block !== "").join(`
+      return parsedBlocks.length === 0 ? {
+        type: "deserialization.failure",
+        mimeType: "text/html",
+        reason: "No blocks deserialized"
+      } : {
+        type: "deserialization.success",
+        data: parsedBlocks,
+        mimeType: "text/html"
+      };
+    }
+  };
+}
+function createConverterTextPlain(legacySchema) {
+  return {
+    mimeType: "text/plain",
+    serialize: ({
+      snapshot,
+      event
+    }) => {
+      const selection = snapshot.beta.internalDrag?.origin.selection ?? snapshot.context.selection;
+      return selection ? {
+        type: "serialization.success",
+        data: sliceBlocks({
+          blocks: snapshot.context.value,
+          selection
+        }).map((block) => isPortableTextTextBlock(block) ? block.children.map((child) => child._type === snapshot.context.schema.span.name ? child.text : snapshot.beta.hasTag("dragging internally") ? `[${snapshot.context.schema.inlineObjects.find((inlineObjectType) => inlineObjectType.name === child._type)?.title ?? "Object"}]` : "").join("") : snapshot.beta.hasTag("dragging internally") ? `[${snapshot.context.schema.blockObjects.find((blockObjectType) => blockObjectType.name === block._type)?.title ?? "Object"}]` : "").filter((block) => block !== "").join(`
 
 `),
-      mimeType: "text/plain",
-      originEvent: event.originEvent
-    } : {
-      type: "serialization.failure",
-      mimeType: "text/plain",
-      originEvent: event.originEvent,
-      reason: "No selection"
-    };
-  },
-  deserialize: ({
-    snapshot,
-    event
-  }) => {
-    const textToHtml = `<html><body>${escapeHtml(event.data).split(/\n{2,}/).map((line) => line ? `<p>${line.replace(/(?:\r\n|\r|\n)/g, "<br/>")}</p>` : "<p></p>").join("")}</body></html>`, parsedBlocks = htmlToBlocks(textToHtml, snapshot.context.schema.portableText, {
-      keyGenerator: snapshot.context.keyGenerator
-    }).flatMap((block) => {
-      const parsedBlock = parseBlock({
-        context: snapshot.context,
-        block,
-        options: {
-          refreshKeys: !1
-        }
+        mimeType: "text/plain",
+        originEvent: event.originEvent
+      } : {
+        type: "serialization.failure",
+        mimeType: "text/plain",
+        originEvent: event.originEvent,
+        reason: "No selection"
+      };
+    },
+    deserialize: ({
+      snapshot,
+      event
+    }) => {
+      const textToHtml = `<html><body>${escapeHtml(event.data).split(/\n{2,}/).map((line) => line ? `<p>${line.replace(/(?:\r\n|\r|\n)/g, "<br/>")}</p>` : "<p></p>").join("")}</body></html>`, parsedBlocks = htmlToBlocks(textToHtml, legacySchema.portableText, {
+        keyGenerator: snapshot.context.keyGenerator
+      }).flatMap((block) => {
+        const parsedBlock = parseBlock({
+          context: snapshot.context,
+          block,
+          options: {
+            refreshKeys: !1
+          }
+        });
+        return parsedBlock ? [parsedBlock] : [];
       });
-      return parsedBlock ? [parsedBlock] : [];
-    });
-    return parsedBlocks.length === 0 ? {
-      type: "deserialization.failure",
-      mimeType: "text/plain",
-      reason: "No blocks deserialized"
-    } : {
-      type: "deserialization.success",
-      data: parsedBlocks,
-      mimeType: "text/plain"
-    };
-  }
-}, entityMap = {
+      return parsedBlocks.length === 0 ? {
+        type: "deserialization.failure",
+        mimeType: "text/plain",
+        reason: "No blocks deserialized"
+      } : {
+        type: "deserialization.success",
+        data: parsedBlocks,
+        mimeType: "text/plain"
+      };
+    }
+  };
+}
+const entityMap = {
   "&": "&amp;",
   "<": "&lt;",
   ">": "&gt;",
@@ -2415,68 +2421,18 @@ const converterJson = {
 function escapeHtml(str) {
   return String(str).replace(/[&<>"'`=/]/g, (s) => entityMap[s]);
 }
-const coreConverters = [converterJson, converterPortableText, converterTextHtml, converterTextPlain];
+function createCoreConverters(legacySchema) {
+  return [converterJson, converterPortableText, createConverterTextHtml(legacySchema), createConverterTextPlain(legacySchema)];
+}
 function compileType(rawType) {
   return Schema.compile({
     name: "blockTypeSchema",
     types: [rawType]
   }).get(rawType.name);
 }
-function createEditorSchema(portableTextType) {
-  if (!portableTextType)
-    throw new Error("Parameter 'portabletextType' missing (required)");
-  const blockType = portableTextType.of?.find(findBlockType);
-  if (!blockType)
-    throw new Error("Block type is not defined in this schema (required)");
-  const childrenField = blockType.fields?.find((field) => field.name === "children");
-  if (!childrenField)
-    throw new Error("Children field for block type found in schema (required)");
-  const ofType = childrenField.type.of;
-  if (!ofType)
-    throw new Error("Valid types for block children not found in schema (required)");
-  const spanType = ofType.find((memberType) => memberType.name === "span");
-  if (!spanType)
-    throw new Error("Span type not found in schema (required)");
-  const inlineObjectTypes = ofType.filter((memberType) => memberType.name !== "span") || [], blockObjectTypes = portableTextType.of?.filter((field) => field.name !== blockType.name) || [];
-  return {
-    styles: resolveEnabledStyles(blockType),
-    decorators: resolveEnabledDecorators(spanType),
-    lists: resolveEnabledListItems(blockType),
-    block: blockType,
-    span: spanType,
-    portableText: portableTextType,
-    inlineObjects: inlineObjectTypes,
-    blockObjects: blockObjectTypes,
-    annotations: spanType.annotations
-  };
-}
-function resolveEnabledStyles(blockType) {
-  const styleField = blockType.fields?.find((btField) => btField.name === "style");
-  if (!styleField)
-    throw new Error("A field with name 'style' is not defined in the block type (required).");
-  const textStyles = styleField.type.options?.list && styleField.type.options.list?.filter((style) => style.value);
-  if (!textStyles || textStyles.length === 0)
-    throw new Error("The style fields need at least one style defined. I.e: {title: 'Normal', value: 'normal'}.");
-  return textStyles;
-}
-function resolveEnabledDecorators(spanType) {
-  return spanType.decorators;
-}
-function resolveEnabledListItems(blockType) {
-  const listField = blockType.fields?.find((btField) => btField.name === "listItem");
-  if (!listField)
-    throw new Error("A field with name 'listItem' is not defined in the block type (required).");
-  const listItems = listField.type.options?.list && listField.type.options.list.filter((list) => list.value);
-  if (!listItems)
-    throw new Error("The list field need at least to be an empty array");
-  return listItems;
-}
-function findBlockType(type) {
-  return type.type ? findBlockType(type.type) : type.name === "block" ? type : null;
-}
 const debug$c = debugWithName("operationToPatches");
-function createOperationToPatches(types) {
-  const textBlockName = types.block.name;
+function createOperationToPatches(editorActor) {
+  const textBlockName = editorActor.getSnapshot().context.schema.block.name;
   function insertTextPatch(editor, operation, beforeValue) {
     debug$c.enabled && debug$c("Operation", JSON.stringify(operation, null, 2));
     const block = editor.isTextBlock(editor.children[operation.path[0]]) && editor.children[operation.path[0]];
@@ -2745,12 +2701,12 @@ function getNextSpan({
   return nextSpan;
 }
 const debug$b = debugWithName("plugin:withPortableTextMarkModel");
-function createWithPortableTextMarkModel(editorActor, types) {
+function createWithPortableTextMarkModel(editorActor) {
   return function(editor) {
     const {
       apply: apply2,
       normalizeNode
-    } = editor, decorators = types.decorators.map((t) => t.value);
+    } = editor, decorators = editorActor.getSnapshot().context.schema.decorators.map((t) => t.name);
     return editor.normalizeNode = (nodeEntry) => {
       const [node, path] = nodeEntry;
       if (editor.isTextBlock(node)) {
@@ -2795,7 +2751,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         return;
       }
       if (editor.isTextSpan(node)) {
-        const blockPath = Path.parent(path), [block] = Editor.node(editor, blockPath), decorators2 = types.decorators.map((decorator) => decorator.value), annotations = node.marks?.filter((mark) => !decorators2.includes(mark));
+        const blockPath = Path.parent(path), [block] = Editor.node(editor, blockPath), decorators2 = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name), annotations = node.marks?.filter((mark) => !decorators2.includes(mark));
         if (editor.isTextBlock(block) && node.text === "" && annotations && annotations.length > 0) {
           debug$b("Removing annotations from empty span node"), editorActor.send({
             type: "normalizing"
@@ -2810,7 +2766,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         }
       }
       if (editor.isTextBlock(node)) {
-        const decorators2 = types.decorators.map((decorator) => decorator.value);
+        const decorators2 = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name);
         for (const [child, childPath] of Node.children(editor, path))
           if (editor.isTextSpan(child)) {
             const marks = child.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !node.markDefs?.find((def) => def._key === mark));
@@ -2831,7 +2787,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
       if (editor.isTextSpan(node)) {
         const blockPath = Path.parent(path), [block] = Editor.node(editor, blockPath);
         if (editor.isTextBlock(block)) {
-          const decorators2 = types.decorators.map((decorator) => decorator.value), marks = node.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
+          const decorators2 = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name), marks = node.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
           if (orphanedAnnotations.length > 0) {
             debug$b("Removing orphaned annotations from span node"), editorActor.send({
               type: "normalizing"
@@ -3082,7 +3038,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
           }
         }
       }
-      if (op.type === "merge_node" && op.path.length === 1 && "markDefs" in op.properties && op.properties._type === types.block.name && Array.isArray(op.properties.markDefs) && op.properties.markDefs.length > 0 && op.path[0] - 1 >= 0) {
+      if (op.type === "merge_node" && op.path.length === 1 && "markDefs" in op.properties && op.properties._type === editorActor.getSnapshot().context.schema.block.name && Array.isArray(op.properties.markDefs) && op.properties.markDefs.length > 0 && op.path[0] - 1 >= 0) {
         const [targetBlock, targetPath] = Editor.node(editor, [op.path[0] - 1]);
         if (editor.isTextBlock(targetBlock)) {
           const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [], newMarkDefs = uniq([...oldDefs, ...op.properties.markDefs]);
@@ -4079,7 +4035,7 @@ const moveBackwardActionImplementation = ({
           continue;
         const marks = child.marks ?? [];
         for (const mark of marks)
-          schema.decorators.some((decorator) => decorator.value === mark) || prevNodeSpans.some((prevNodeSpan) => prevNodeSpan.marks?.includes(mark)) && !newMarkDefKeys.has(mark) && newMarkDefKeys.set(mark, keyGenerator());
+          schema.decorators.some((decorator) => decorator.name === mark) || prevNodeSpans.some((prevNodeSpan) => prevNodeSpan.marks?.includes(mark)) && !newMarkDefKeys.has(mark) && newMarkDefKeys.set(mark, keyGenerator());
         const newMarks = marks.map((mark) => newMarkDefKeys.get(mark) ?? mark);
         isEqual(marks, newMarks) || Transforms.setNodes(editor, {
           marks: newMarks
@@ -4500,7 +4456,7 @@ function createWithMaxBlocks(editorActor) {
     }, editor;
   };
 }
-function createWithObjectKeys(editorActor, schemaTypes) {
+function createWithObjectKeys(editorActor) {
   return function(editor) {
     const {
       apply: apply2,
@@ -4540,7 +4496,7 @@ function createWithObjectKeys(editorActor, schemaTypes) {
       apply2(operation);
     }, 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) {
         if (!node._key) {
           editorActor.send({
             type: "normalizing"
@@ -4572,7 +4528,7 @@ function createWithObjectKeys(editorActor, schemaTypes) {
   };
 }
 const debug$9 = debugWithName("applyPatches"), debugVerbose = debug$9.enabled && !0;
-function createApplyPatch(schemaTypes) {
+function createApplyPatch(schema) {
   return (editor, patch) => {
     let changed = !1;
     debugVerbose && (debug$9(`
@@ -4581,7 +4537,7 @@ NEW PATCH =============================================================`), debug
     try {
       switch (patch.type) {
         case "insert":
-          changed = insertPatch(editor, patch, schemaTypes);
+          changed = insertPatch(editor, patch, schema);
           break;
         case "unset":
           changed = unsetPatch(editor, patch);
@@ -4632,7 +4588,7 @@ function diffMatchPatch(editor, patch) {
     }) : op === DIFF_EQUAL && (offset += text.length);
   return debugState(editor, "after"), !0;
 }
-function insertPatch(editor, patch, schemaTypes) {
+function insertPatch(editor, patch, schema) {
   const {
     block: targetBlock,
     child: targetChild,
@@ -4648,7 +4604,7 @@ function insertPatch(editor, patch, schemaTypes) {
       items: items2,
       position: position2
     } = patch, blocksToInsert = toSlateValue(items2, {
-      schemaTypes
+      schemaTypes: schema
     }, KEY_TO_SLATE_ELEMENT.get(editor)), targetBlockIndex = targetBlockPath[0], normalizedIdx2 = position2 === "after" ? targetBlockIndex + 1 : targetBlockIndex;
     return debug$9(`Inserting blocks at path [${normalizedIdx2}]`), debugState(editor, "before"), Transforms.insertNodes(editor, blocksToInsert, {
       at: [normalizedIdx2]
@@ -4664,7 +4620,7 @@ function insertPatch(editor, patch, schemaTypes) {
     ...targetBlock,
     children: items
   }], {
-    schemaTypes
+    schemaTypes: schema
   }, KEY_TO_SLATE_ELEMENT.get(editor)), targetChildIndex = targetChildPath[1], normalizedIdx = position === "after" ? targetChildIndex + 1 : targetChildIndex, childInsertPath = [targetChildPath[0], normalizedIdx];
   return debug$9(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && Element.isElement(childrenToInsert[0]) && Transforms.insertNodes(editor, childrenToInsert[0].children, {
     at: childInsertPath
@@ -4842,11 +4798,10 @@ const debug$8 = debugWithName("plugin:withPatches");
 function createWithPatches({
   editorActor,
   patchFunctions,
-  schemaTypes,
   subscriptions
 }) {
   let previousChildren;
-  const applyPatch = createApplyPatch(schemaTypes);
+  const applyPatch = createApplyPatch(editorActor.getSnapshot().context.schema);
   return function(editor) {
     IS_PROCESSING_REMOTE_CHANGES.set(editor, !1), PATCHING.set(editor, !0), previousChildren = [...editor.children];
     const {
@@ -4885,9 +4840,9 @@ function createWithPatches({
     }), editor.apply = (operation) => {
       let patches = [];
       previousChildren = editor.children;
-      const editorWasEmpty = isEqualToEmptyEditor(previousChildren, schemaTypes);
+      const editorWasEmpty = isEqualToEmptyEditor(previousChildren, editorActor.getSnapshot().context.schema);
       apply2(operation);
-      const editorIsEmpty = isEqualToEmptyEditor(editor.children, schemaTypes);
+      const editorIsEmpty = isEqualToEmptyEditor(editor.children, editorActor.getSnapshot().context.schema);
       if (!isPatching(editor))
         return editor;
       switch (editorWasEmpty && !editorIsEmpty && operation.type !== "set_selection" && patches.push(insert(previousChildren, "before", [0])), operation.type) {
@@ -4918,7 +4873,7 @@ function createWithPatches({
       }
       if (!editorWasEmpty && editorIsEmpty && ["merge_node", "set_node", "remove_text", "remove_node"].includes(operation.type) && (patches = [...patches, unset([])], editorActor.send({
         type: "notify.unset",
-        previousValue: fromSlateValue(previousChildren, schemaTypes.block.name, KEY_TO_VALUE_ELEMENT.get(editor))
+        previousValue: fromSlateValue(previousChildren, editorActor.getSnapshot().context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor))
       })), editorWasEmpty && patches.length > 0 && (patches = [setIfMissing([], []), ...patches]), patches.length > 0)
         for (const patch of patches)
           editorActor.send({
@@ -4928,7 +4883,7 @@ function createWithPatches({
               origin: "local"
             },
             actionId: getCurrentActionId(editor),
-            value: fromSlateValue(editor.children, schemaTypes.block.name, KEY_TO_VALUE_ELEMENT.get(editor))
+            value: fromSlateValue(editor.children, editorActor.getSnapshot().context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(editor))
           });
       return editor;
     }, editor;
@@ -4969,8 +4924,8 @@ function createWithPlaceholderBlock(editorActor) {
   };
 }
 const debug$6 = debugWithName("plugin:withPortableTextBlockStyle");
-function createWithPortableTextBlockStyle(editorActor, types) {
-  const defaultStyle = types.styles[0].value;
+function createWithPortableTextBlockStyle(editorActor) {
+  const defaultStyle = editorActor.getSnapshot().context.schema.styles[0].name;
   return function(editor) {
     const {
       normalizeNode
@@ -5034,11 +4989,10 @@ function createWithPortableTextSelections(editorActor) {
 }
 const debug$5 = debugWithName("plugin:withSchemaTypes");
 function createWithSchemaTypes({
-  editorActor,
-  schemaTypes
+  editorActor
 }) {
   return function(editor) {
-    editor.isTextBlock = (value) => isPortableTextTextBlock(value) && value._type === schemaTypes.block.name, editor.isTextSpan = (value) => isPortableTextSpan$1(value) && value._type === schemaTypes.span.name, editor.isListBlock = (value) => isPortableTextListBlock(value) && value._type === schemaTypes.block.name, editor.isVoid = (element) => schemaTypes.block.name !== element._type && (schemaTypes.blockObjects.map((obj) => obj.name).includes(element._type) || schemaTypes.inlineObjects.map((obj) => obj.name).includes(element._type)), editor.isInline = (element) => schemaTypes.inlineObjects.map((obj) => obj.name).includes(element._type) && "__inline" in element && element.__inline === !0;
+    editor.isTextBlock = (value) => isPortableTextTextBlock(value) && value._type === editorActor.getSnapshot().context.schema.block.name, editor.isTextSpan = (value) => isPortableTextSpan$1(value) && value._type === editorActor.getSnapshot().context.schema.span.name, editor.isListBlock = (value) => isPortableTextListBlock(value) && value._type === editorActor.getSnapshot().context.schema.block.name, editor.isVoid = (element) => editorActor.getSnapshot().context.schema.block.name !== element._type && (editorActor.getSnapshot().context.schema.blockObjects.map((obj) => obj.name).includes(element._type) || editorActor.getSnapshot().context.schema.inlineObjects.map((obj) => obj.name).includes(element._type)), editor.isInline = (element) => editorActor.getSnapshot().context.schema.inlineObjects.map((obj) => obj.name).includes(element._type) && "__inline" in element && element.__inline === !0;
     const {
       normalizeNode
     } = editor;
@@ -5051,7 +5005,7 @@ function createWithSchemaTypes({
           type: "normalizing"
         }), Transforms.setNodes(editor, {
           ...span,
-          _type: schemaTypes.span.name,
+          _type: editorActor.getSnapshot().context.schema.span.name,
           _key: key
         }, {
           at: path
@@ -5079,14 +5033,13 @@ function createWithSchemaTypes({
   };
 }
 function createWithUtils({
-  editorActor,
-  schemaTypes
+  editorActor
 }) {
   return function(editor) {
     return editor.pteCreateTextBlock = (options) => 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
       } : {},
@@ -5098,33 +5051,29 @@ function createWithUtils({
         _type: "span",
         _key: editorActor.getSnapshot().context.keyGenerator(),
         text: "",
-        marks: options.decorators.filter((decorator) => schemaTypes.decorators.find(({
-          value
-        }) => value === decorator))
+        marks: options.decorators.filter((decorator) => editorActor.getSnapshot().context.schema.decorators.find(({
+          name
+        }) => name === decorator))
       }]
     }], {
-      schemaTypes
+      schemaTypes: editorActor.getSnapshot().context.schema
     })[0], editor;
   };
 }
 const withPlugins = (editor, options) => {
   const e = editor, {
     editorActor
-  } = options, schemaTypes = editorActor.getSnapshot().context.schema, operationToPatches = createOperationToPatches(schemaTypes), withObjectKeys = createWithObjectKeys(editorActor, schemaTypes), withSchemaTypes = createWithSchemaTypes({
-    editorActor,
-    schemaTypes
+  } = options, operationToPatches = createOperationToPatches(editorActor), withObjectKeys = createWithObjectKeys(editorActor), withSchemaTypes = createWithSchemaTypes({
+    editorActor
   }), withPatches = createWithPatches({
     editorActor,
     patchFunctions: operationToPatches,
-    schemaTypes,
     subscriptions: options.subscriptions
   }), withMaxBlocks = createWithMaxBlocks(editorActor), withUndoRedo = createWithUndoRedo({
     editorActor,
-    blockSchemaType: schemaTypes.block,
     subscriptions: options.subscriptions
-  }), withPortableTextMarkModel = createWithPortableTextMarkModel(editorActor, schemaTypes), withPortableTextBlockStyle = createWithPortableTextBlockStyle(editorActor, schemaTypes), withPlaceholderBlock = createWithPlaceholderBlock(editorActor), withUtils = createWithUtils({
-    editorActor,
-    schemaTypes
+  }), withPortableTextMarkModel = createWithPortableTextMarkModel(editorActor), withPortableTextBlockStyle = createWithPortableTextBlockStyle(editorActor), withPlaceholderBlock = createWithPlaceholderBlock(editorActor), withUtils = createWithUtils({
+    editorActor
   }), withPortableTextSelections = createWithPortableTextSelections(editorActor);
   return createWithEventListeners(editorActor)(withSchemaTypes(withObjectKeys(withPortableTextMarkModel(withPortableTextBlockStyle(withPlaceholderBlock(withUtils(withMaxBlocks(withUndoRedo(withPatches(withPortableTextSelections(e)))))))))));
 }, debug$4 = debugWithName("component:PortableTextEditor:SlateContainer"), slateEditors = /* @__PURE__ */ new WeakMap();
@@ -5148,100 +5097,6 @@ function createSlateEditor(config) {
   };
   return slateEditors.set(config.editorActor, slateEditor), slateEditor;
 }
-function defineSchema(definition) {
-  return definition;
-}
-const temporaryImageName = `tmp-${defaultKeyGenerator()}-image`, temporaryUrlName = `tmp-${defaultKeyGenerator()}-url`, temporaryObjectNames = {
-  image: temporaryImageName,
-  url: temporaryUrlName
-}, objectNames = {
-  [temporaryImageName]: "image",
-  [temporaryUrlName]: "url"
-}, defaultObjectTitles = {
-  image: "Image",
-  url: "URL"
-};
-function compileSchemaDefinition(definition) {
-  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 === void 0 ? (
-      // 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
-    })) ?? []
-  })) ?? [], 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 === void 0 ? (
-      // 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
-    })) ?? []
-  })) ?? [], 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,
-            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)
-      })) ?? []
-    }]
-  }), schema = Schema.compile({
-    types: [portableTextSchema, ...blockObjects, ...inlineObjects]
-  }).get("portable-text"), pteSchema = createEditorSchema(schema);
-  return {
-    ...pteSchema,
-    blockObjects: pteSchema.blockObjects.map((blockObject) => objectNames[blockObject.name] !== void 0 ? {
-      ...blockObject,
-      name: objectNames[blockObject.name],
-      type: {
-        ...blockObject.type,
-        name: objectNames[blockObject.name]
-      }
-    } : blockObject),
-    inlineObjects: pteSchema.inlineObjects.map((inlineObject) => objectNames[inlineObject.name] !== void 0 ? {
-      ...inlineObject,
-      name: objectNames[inlineObject.name]
-    } : inlineObject)
-  };
-}
 const abstractAnnotationBehaviors = [defineBehavior({
   on: "annotation.toggle",
   guard: ({
@@ -6218,7 +6073,7 @@ function getActiveDecorators({
   schema,
   slateEditorInstance
 }) {
-  const decorators = schema.decorators.map((decorator) => decorator.value);
+  const decorators = schema.decorators.map((decorator) => decorator.name);
   return ({
     ...Editor.marks(slateEditorInstance) ?? {}
   }.marks ?? []).filter((mark) => decorators.includes(mark));
@@ -6643,6 +6498,201 @@ const editorMachine = setup({
     }
   }
 });
+function createLegacySchema(portableTextType) {
+  if (!portableTextType)
+    throw new Error("Parameter 'portabletextType' missing (required)");
+  const blockType = portableTextType.of?.find(findBlockType);
+  if (!blockType)
+    throw new Error("Block type is not defined in this schema (required)");
+  const childrenField = blockType.fields?.find((field) => field.name === "children");
+  if (!childrenField)
+    throw new Error("Children field for block type found in schema (required)");
+  const ofType = childrenField.type.of;
+  if (!ofType)
+    throw new Error("Valid types for block children not found in schema (required)");
+  const spanType = ofType.find((memberType) => memberType.name === "span");
+  if (!spanType)
+    throw new Error("Span type not found in schema (required)");
+  const inlineObjectTypes = ofType.filter((memberType) => memberType.name !== "span") || [], blockObjectTypes = portableTextType.of?.filter((field) => field.name !== blockType.name) || [];
+  return {
+    styles: resolveEnabledStyles(blockType),
+    decorators: resolveEnabledDecorators(spanType),
+    lists: resolveEnabledListItems(blockType),
+    block: blockType,
+    span: spanType,
+    portableText: portableTextType,
+    inlineObjects: inlineObjectTypes,
+    blockObjects: blockObjectTypes,
+    annotations: spanType.annotations
+  };
+}
+function resolveEnabledStyles(blockType) {
+  const styleField = blockType.fields?.find((btField) => btField.name === "style");
+  if (!styleField)
+    throw new Error("A field with name 'style' is not defined in the block type (required).");
+  const textStyles = styleField.type.options?.list && styleField.type.options.list?.filter((style) => style.value);
+  if (!textStyles || textStyles.length === 0)
+    throw new Error("The style fields need at least one style defined. I.e: {title: 'Normal', value: 'normal'}.");
+  return textStyles;
+}
+function resolveEnabledDecorators(spanType) {
+  return spanType.decorators;
+}
+function resolveEnabledListItems(blockType) {
+  const listField = blockType.fields?.find((btField) => btField.name === "listItem");
+  if (!listField)
+    throw new Error("A field with name 'listItem' is not defined in the block type (required).");
+  const listItems = listField.type.options?.list && listField.type.options.list.filter((list) => list.value);
+  if (!listItems)
+    throw new Error("The list field need at least to be an empty array");
+  return listItems;
+}
+function findBlockType(type) {
+  return type.type ? findBlockType(type.type) : type.name === "block" ? type : null;
+}
+function defineSchema(definition) {
+  return definition;
+}
+const temporaryImageName = `tmp-${defaultKeyGenerator()}-image`, temporaryUrlName = `tmp-${defaultKeyGenerator()}-url`, temporaryObjectNames = {
+  image: temporaryImageName,
+  url: temporaryUrlName
+}, objectNames = {
+  [temporaryImageName]: "image",
+  [temporaryUrlName]: "url"
+}, defaultObjectTitles = {
+  image: "Image",
+  url: "URL"
+};
+function legacySchemaToEditorSchema(schema) {
+  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
+    }))
+  };
+}
+function compileSchemaDefinitionToLegacySchema(definition) {
+  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 === void 0 ? (
+      // 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
+    })) ?? []
+  })) ?? [], 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 === void 0 ? (
+      // 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
+    })) ?? []
+  })) ?? [], 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,
+            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)
+      })) ?? []
+    }]
+  }), schema = Schema.compile({
+    types: [portableTextSchema, ...blockObjects, ...inlineObjects]
+  }).get("portable-text"), pteSchema = createLegacySchema(schema);
+  return {
+    ...pteSchema,
+    blockObjects: pteSchema.blockObjects.map((blockObject) => objectNames[blockObject.name] !== void 0 ? {
+      ...blockObject,
+      name: objectNames[blockObject.name],
+      type: {
+        ...blockObject.type,
+        name: objectNames[blockObject.name]
+      }
+    } : blockObject),
+    inlineObjects: pteSchema.inlineObjects.map((inlineObject) => objectNames[inlineObject.name] !== void 0 ? {
+      ...inlineObject,
+      name: objectNames[inlineObject.name]
+    } : inlineObject)
+  };
+}
 function defaultCompare(a, b) {
   return a === b;
 }
@@ -7051,35 +7101,37 @@ function isAnnotationActive({
   }
 }
 function createInternalEditor(config) {
-  const editorActor = createActor(editorMachine, {
-    input: editorConfigToMachineInput(config)
+  const legacySchema = config.schemaDefinition ? compileSchemaDefinitionToLegacySchema(config.schemaDefinition) : createLegacySchema(config.schema.hasOwnProperty("jsonType") ? config.schema : compileType(config.schema)), editorSchema = legacySchemaToEditorSchema(legacySchema), editorActor = createActor(editorMachine, {
+    input: editorConfigToMachineInput({
+      ...config,
+      schema: editorSchema,
+      legacySchema
+    })
   });
-  return editorActor.start(), createInternalEditorFromActor(editorActor);
+  return editorActor.start(), createInternalEditorFromActor(editorActor, legacySchema);
 }
 function useCreateInternalEditor(config) {
-  const $ = c(6);
-  let t0;
-  $[0] !== config ? (t0 = editorConfigToMachineInput(config), $[0] = config, $[1] = t0) : t0 = $[1];
-  let t1;
-  $[2] !== t0 ? (t1 = {
-    input: t0
-  }, $[2] = t0, $[3] = t1) : t1 = $[3];
-  const editorActor = useActorRef(editorMachine, t1);
-  let t2, t3;
-  return $[4] !== editorActor ? (t3 = createInternalEditorFromActor(editorActor), $[4] = editorActor, $[5] = t3) : t3 = $[5], t2 = t3, t2;
+  const legacySchema = config.schemaDefinition ? compileSchemaDefinitionToLegacySchema(config.schemaDefinition) : createLegacySchema(config.schema.hasOwnProperty("jsonType") ? config.schema : compileType(config.schema)), editorSchema = legacySchemaToEditorSchema(legacySchema), editorActor = useActorRef(editorMachine, {
+    input: editorConfigToMachineInput({
+      ...config,
+      schema: editorSchema,
+      legacySchema
+    })
+  });
+  return useMemo(() => createInternalEditorFromActor(editorActor, legacySchema), [editorActor, legacySchema]);
 }
 function editorConfigToMachineInput(config) {
   return {
     behaviors: config.behaviors,
-    converters: coreConverters,
+    converters: createCoreConverters(config.legacySchema),
     keyGenerator: config.keyGenerator ?? defaultKeyGenerator,
     maxBlocks: config.maxBlocks,
     readOnly: config.readOnly,
-    schema: config.schemaDefinition ? compileSchemaDefinition(config.schemaDefinition) : createEditorSchema(config.schema.hasOwnProperty("jsonType") ? config.schema : compileType(config.schema)),
+    schema: config.schema,
     initialValue: config.initialValue
   };
 }
-function createInternalEditorFromActor(editorActor) {
+function createInternalEditorFromActor(editorActor, legacySchema) {
   const slateEditor = createSlateEditor({
     editorActor
   }), editable = createEditableAPI(slateEditor.instance, editorActor);
@@ -7154,6 +7206,7 @@ function createInternalEditorFromActor(editorActor) {
     _internal: {
       editable,
       editorActor,
+      legacySchema,
       slateEditor
     }
   };
@@ -7209,12 +7262,12 @@ class PortableTextEditor extends Component {
       initialValue: props.value,
       maxBlocks: props.maxBlocks === void 0 ? void 0 : Number.parseInt(props.maxBlocks.toString(), 10),
       readOnly: props.readOnly
-    }), this.schemaTypes = this.editor._internal.editorActor.getSnapshot().context.schema, this.editable = this.editor._internal.editable;
+    }), this.schemaTypes = this.editor._internal.legacySchema, this.editable = this.editor._internal.editable;
   }
   componentDidUpdate(prevProps) {
-    !this.props.editor && !prevProps.editor && this.props.schemaType !== prevProps.schemaType && (this.schemaTypes = createEditorSchema(this.props.schemaType.hasOwnProperty("jsonType") ? this.props.schemaType : compileType(this.props.schemaType)), this.editor._internal.editorActor.send({
+    !this.props.editor && !prevProps.editor && this.props.schemaType !== prevProps.schemaType && (this.schemaTypes = createLegacySchema(this.props.schemaType.hasOwnProperty("jsonType") ? this.props.schemaType : compileType(this.props.schemaType)), this.editor._internal.editorActor.send({
       type: "update schema",
-      schema: this.schemaTypes
+      schema: legacySchemaToEditorSchema(this.schemaTypes)
     })), !this.props.editor && !prevProps.editor && (this.props.readOnly !== prevProps.readOnly && this.editor._internal.editorActor.send({
       type: "update readOnly",
       readOnly: this.props.readOnly ?? !1