@portabletext/editor 7.10.0 → 7.10.1

package/lib/index.js

@@ -7717,6 +7717,15 @@ function transformRangeRef(ref, op, root) {
   });
   ref.current = path2, path2 == null && ref.unref();
 }
+function splitNodePath(path2) {
+  let nodePathEnd = path2.length;
+  for (; nodePathEnd > 0 && typeof path2[nodePathEnd - 1] == "string"; )
+    nodePathEnd--;
+  return {
+    nodePath: path2.slice(0, nodePathEnd),
+    propertyPath: path2.slice(nodePathEnd)
+  };
+}
 function findNearestSpans(snapshot, path2) {
   return {
     previousSpan: findPreviousSpan(snapshot, path2),
@@ -7787,10 +7796,7 @@ function lastSpanIn(snapshot, path2) {
     return entry;
 }
 function nodeParentPath(path2) {
-  let end2 = path2.length - 1;
-  for (; end2 > 0 && typeof path2[end2 - 1] == "string"; )
-    end2--;
-  return path2.slice(0, end2);
+  return splitNodePath(path2.slice(0, -1)).nodePath;
 }
 function getValue(root, path2) {
   let current = root;
@@ -8021,7 +8027,7 @@ function applyOperation(editor, op) {
       const {
         nodePath: setNodePath,
         propertyPath: setPropertyPath
-      } = splitNodeAndPropertyPath(path2);
+      } = splitNodePath(path2);
       if (setNodePath.length === 0)
         break;
       if (setPropertyPath.length === 0) {
@@ -8122,7 +8128,7 @@ function applyOperation(editor, op) {
       const {
         nodePath: unsetNodePath,
         propertyPath: unsetPropertyPath
-      } = splitNodeAndPropertyPath(path2);
+      } = splitNodePath(path2);
       if (unsetPropertyPath.length === 0 || unsetNodePath.length === 0)
         break;
       if (!op.inverse && !editor.isProcessingRemoteChanges) {
@@ -8229,26 +8235,6 @@ function resolveBlockIndex(editor, segment) {
   const value = editor.snapshot.context.value, index = editor.blockIndexMap.get(serializePath([segment]));
   return index !== void 0 && value[index]?._key === segment._key ? index : value.findIndex((block) => block._key === segment._key);
 }
-function splitNodeAndPropertyPath(path2) {
-  let lastKeyedOrNumericIndex = -1;
-  for (let i = path2.length - 1; i >= 0; i--) {
-    const segment = path2[i];
-    if (isKeyedSegment(segment) || typeof segment == "number") {
-      lastKeyedOrNumericIndex = i;
-      break;
-    }
-  }
-  if (lastKeyedOrNumericIndex === -1)
-    return {
-      nodePath: [],
-      propertyPath: path2.filter((segment) => typeof segment == "string")
-    };
-  const nodePath = path2.slice(0, lastKeyedOrNumericIndex + 1), propertyPath = path2.slice(lastKeyedOrNumericIndex + 1).filter((segment) => typeof segment == "string");
-  return {
-    nodePath,
-    propertyPath
-  };
-}
 function deepSet(node, propertyPath, value) {
   if (propertyPath.length === 0)
     return node;
@@ -10489,7 +10475,7 @@ function transformBlockIndexMap(map, op, beforeValue, afterValue, context) {
         return;
       }
       if (typeof op.path[op.path.length - 1] == "string") {
-        hasKeyedEntries(resolveValueAtPath(beforeValue, op.path)) && reconcileOwnerSubtree(map, context, beforeValue, afterValue, op.path);
+        hasKeyedEntries(getValue(beforeValue, op.path)) && reconcileOwnerSubtree(map, context, beforeValue, afterValue, op.path);
         return;
       }
       const removeIndex = childIndexFromMap(map, beforeValue, op.path);
@@ -10517,7 +10503,7 @@ function transformBlockIndexMap(map, op, beforeValue, afterValue, context) {
           handleKeyChange(map, beforeValue, afterValue, op.path.slice(0, -1), context);
           return;
         }
-        (op.value !== null && typeof op.value == "object" || hasKeyedEntries(resolveValueAtPath(beforeValue, op.path))) && reconcileOwnerSubtree(map, context, beforeValue, afterValue, op.path);
+        (op.value !== null && typeof op.value == "object" || hasKeyedEntries(getValue(beforeValue, op.path))) && reconcileOwnerSubtree(map, context, beforeValue, afterValue, op.path);
         return;
       }
       const childIndex = childIndexFromMap(map, beforeValue, op.path);
@@ -10654,33 +10640,14 @@ function resolveIndexableNode(context, value, keyedPath) {
   };
 }
 function reconcileOwnerSubtree(map, context, beforeValue, afterValue, propertyPath) {
-  let ownerPathEnd = propertyPath.length;
-  for (; ownerPathEnd > 0 && typeof propertyPath[ownerPathEnd - 1] == "string"; )
-    ownerPathEnd--;
-  if (ownerPathEnd === 0)
-    return;
-  const ownerPath = propertyPath.slice(0, ownerPathEnd);
-  pruneSubtreeAtPath(
+  const ownerPath = splitNodePath(propertyPath).nodePath;
+  ownerPath.length !== 0 && (pruneSubtreeAtPath(
     map,
     beforeValue,
     ownerPath,
     /*keepSelf*/
     !0
-  ), addSubtree(map, context, afterValue, ownerPath);
-}
-function resolveValueAtPath(value, path2) {
-  let nodePathEnd = path2.length;
-  for (; nodePathEnd > 0 && typeof path2[nodePathEnd - 1] == "string"; )
-    nodePathEnd--;
-  if (nodePathEnd === 0)
-    return;
-  let current = resolveNodeAtPath(value, path2.slice(0, nodePathEnd));
-  for (let i = nodePathEnd; i < path2.length; i++) {
-    if (current === null || typeof current != "object")
-      return;
-    current = current[path2[i]];
-  }
-  return current;
+  ), addSubtree(map, context, afterValue, ownerPath));
 }
 function hasKeyedEntries(value) {
   return Array.isArray(value) && value.some((entry) => entry !== null && typeof entry == "object" && entry._key !== void 0);
@@ -16900,15 +16867,17 @@ function synthesizeBlockChildrenField(schema) {
     of: ofMembers
   };
 }
-function resolveFieldOn(fields, type, fieldName) {
+function resolveFieldOn(fields, fieldName) {
   const field = fields.find((candidate) => candidate.name === fieldName);
-  if (!(!field || !isChildArrayField(field))) {
-    if (containsOnlyPrimitiveTypes(field)) {
-      console.warn(`Field '${field.name}' on '${type}' doesn't contain block or container types and will be excluded`);
-      return;
-    }
-    return field;
-  }
+  return field ? isChildArrayField(field) ? containsOnlyPrimitiveTypes(field) ? {
+    failure: "field-primitive-only"
+  } : {
+    field
+  } : {
+    failure: "field-not-array"
+  } : {
+    failure: "field-missing"
+  };
 }
 function findInlineDeclarationIn(parentOf, type) {
   for (const member of parentOf)
@@ -16936,28 +16905,35 @@ function findInlineFields(schema, type) {
         isChildArrayField(field) && walk(field.of);
   return best;
 }
-function resolveContainerField(schema, type, fieldName, parentOf) {
+function resolveContainerFieldResolution(schema, type, fieldName, parentOf) {
   if (type === "block")
-    return fieldName !== "children" ? void 0 : synthesizeBlockChildrenField(schema);
+    return fieldName !== "children" ? {
+      failure: "field-missing"
+    } : {
+      field: synthesizeBlockChildrenField(schema)
+    };
   if (parentOf) {
     const inlineMatch = findInlineDeclarationIn(parentOf, type);
     if (inlineMatch)
-      return resolveFieldOn(inlineMatch, type, fieldName);
+      return resolveFieldOn(inlineMatch, fieldName);
   }
   const rootMatch = schema.blockObjects.find((blockObject) => blockObject.name === type), rootFields = rootMatch && "fields" in rootMatch && rootMatch.fields && rootMatch.fields.length > 0 ? rootMatch.fields : void 0, inlineFields = rootFields ? void 0 : findInlineFields(schema, type), fields = rootFields ?? inlineFields;
-  if (fields)
-    return resolveFieldOn(fields, type, fieldName);
+  return fields ? resolveFieldOn(fields, fieldName) : rootMatch ? {
+    failure: "field-missing"
+  } : {
+    failure: "unknown-type"
+  };
 }
 function resolveNestedContainer(schema, container, chain = [], onFailure = "warn", parentOf) {
-  const field = resolveContainerField(schema, container.type, container.arrayField, parentOf);
-  if (!field) {
-    const location = chain.length > 0 ? ` (nested inside ${chain.map((type) => `"${type}"`).join(" inside ")})` : "", message = `registerNode: field "${container.arrayField}" not found on type "${container.type}"${location}. Registration skipped.`;
+  const resolution = resolveContainerFieldResolution(schema, container.type, container.arrayField, parentOf);
+  if ("failure" in resolution) {
+    const location = chain.length > 0 ? ` (nested inside ${chain.map((type) => `"${type}"`).join(" inside ")})` : "", message = `registerNode: ${describeContainerFailure(resolution.failure, container)}${location}. Registration skipped.`;
     if (onFailure === "throw")
       throw new Error(message);
     console.warn(message);
     return;
   }
-  const nextChain = [...chain, container.type], resolvedOf = container.of ? container.of.flatMap((entry) => {
+  const field = resolution.field, nextChain = [...chain, container.type], resolvedOf = container.of ? container.of.flatMap((entry) => {
     if (entry.kind === "container") {
       const resolved = resolveNestedContainer(schema, entry, nextChain, onFailure, field.of);
       return resolved ? [resolved] : [];
@@ -16974,6 +16950,18 @@ function resolveNestedContainer(schema, container, chain = [], onFailure = "warn
     } : {}
   };
 }
+function describeContainerFailure(failure, container) {
+  switch (failure) {
+    case "unknown-type":
+      return `type "${container.type}" not found in the schema`;
+    case "field-missing":
+      return `field "${container.arrayField}" not found on type "${container.type}"`;
+    case "field-not-array":
+      return `field "${container.arrayField}" on type "${container.type}" is not an array`;
+    case "field-primitive-only":
+      return `field "${container.arrayField}" on type "${container.type}" contains only primitive types and cannot hold block content`;
+  }
+}
 function resolveTextBlockConfig(textBlock) {
   const resolvedOf = textBlock.of ? textBlock.of.flatMap((entry) => entry.kind === "span" ? [{
     span: entry