@portabletext/editor 2.3.3 → 2.3.4

package/lib/index.js

@@ -17,6 +17,9 @@ import getRandomValues from "get-random-values-esm";
 import { defineBehavior, forward, raise, effect } from "./behaviors/index.js";
 import uniq from "lodash/uniq.js";
 import { Subject } from "rxjs";
+import { compileSchemaDefinitionToPortableTextMemberSchemaTypes, createPortableTextMemberSchemaTypes, portableTextMemberSchemaTypesToSchema } from "@portabletext/sanity-bridge";
+import { compileSchema } from "@portabletext/schema";
+import { defineSchema } from "@portabletext/schema";
 import { setup, assign, enqueueActions, emit, assertEvent, stateIn, fromCallback, and, not, raise as raise$1, createActor } from "xstate";
 import { htmlToBlocks } from "@portabletext/block-tools";
 import { toHTML } from "@portabletext/to-html";
@@ -31,8 +34,6 @@ import isUndefined from "lodash/isUndefined.js";
 import omitBy from "lodash/omitBy.js";
 import { createDraft, finishDraft } from "immer";
 import { createKeyboardShortcut, code, underline, italic, bold, undo, redo } from "@portabletext/keyboard-shortcuts";
-import { defineType, defineField } from "@sanity/types";
-import startCase from "lodash.startcase";
 import isPlainObject from "lodash/isPlainObject.js";
 function EditorEventListener(props) {
   const $ = c(4), editor = useEditor();
@@ -8473,245 +8474,7 @@ const debug$7 = debugWithName("editor machine"), 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;
-}
-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: 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
-    }))
-  };
-}
-function compileSchemaDefinition(definition) {
-  const styles = (definition.styles ?? []).map((style) => ({
-    ...style,
-    value: style.name
-  }));
-  return {
-    block: {
-      name: "block"
-    },
-    span: {
-      name: "span"
-    },
-    styles: styles.some((style) => style.value === "normal") ? styles : [{
-      value: "normal",
-      name: "normal",
-      title: "Normal"
-    }, ...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 ?? []
-    }))
-  };
-}
-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,
-      title: field.title ?? startCase(field.name)
-    })) ?? []
-  })) ?? [], 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,
-      title: field.title ?? startCase(field.name)
-    })) ?? []
-  })) ?? [], 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)
-      })) ?? []
-    }]
-  }), 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)
-  };
-}
-const debug$6 = debugWithName("mutation-machine"), mutationMachine = setup({
+}), debug$6 = debugWithName("mutation-machine"), mutationMachine = setup({
   types: {
     context: {},
     events: {},
@@ -10349,7 +10112,7 @@ function editorConfigToMachineInput(config) {
   };
 }
 function compileSchemasFromEditorConfig(config) {
-  const legacySchema = config.schemaDefinition ? compileSchemaDefinitionToLegacySchema(config.schemaDefinition) : createLegacySchema(config.schema.hasOwnProperty("jsonType") ? config.schema : compileType(config.schema)), schema = config.schemaDefinition ? compileSchemaDefinition(config.schemaDefinition) : legacySchemaToEditorSchema(legacySchema);
+  const legacySchema = config.schemaDefinition ? compileSchemaDefinitionToPortableTextMemberSchemaTypes(config.schemaDefinition) : createPortableTextMemberSchemaTypes(config.schema.hasOwnProperty("jsonType") ? config.schema : compileType(config.schema)), schema = config.schemaDefinition ? compileSchema(config.schemaDefinition) : portableTextMemberSchemaTypesToSchema(legacySchema);
   return {
     legacySchema,
     schema
@@ -12111,9 +11874,6 @@ function EditorProvider(props) {
   let t7;
   return $[25] !== internalEditor_0.editor || $[26] !== t6 ? (t7 = /* @__PURE__ */ jsx(EditorContext.Provider, { value: internalEditor_0.editor, children: t6 }), $[25] = internalEditor_0.editor, $[26] = t6, $[27] = t7) : t7 = $[27], t7;
 }
-function defineSchema(definition) {
-  return definition;
-}
 const usePortableTextEditorSelection = () => {
   const $ = c(3), editorActor = useContext(EditorActorContext), [selection, setSelection2] = useState(null);
   let t0, t1;