@portabletext/editor 1.16.1 → 1.16.3

package/lib/index.cjs

@@ -11,11 +11,11 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
   return a;
 };
 Object.defineProperty(exports, "__esModule", { value: !0 });
-var schema = require("@sanity/schema"), types = require("@sanity/types"), startCase = require("lodash.startcase"), jsxRuntime = require("react/jsx-runtime"), react = require("@xstate/react"), isEqual = require("lodash/isEqual.js"), noop = require("lodash/noop.js"), React = require("react"), slate = require("slate"), slateReact = require("slate-react"), debug$m = require("debug"), reactCompilerRuntime = require("react-compiler-runtime"), styledComponents = require("styled-components"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), useEffectEvent = require("use-effect-event"), xstate = require("xstate"), patches = require("@portabletext/patches"), flatten = require("lodash/flatten.js"), isPlainObject = require("lodash/isPlainObject.js"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), selector_isSelectionCollapsed = require("./_chunks-cjs/selector.is-selection-collapsed.cjs"), behavior_core = require("./_chunks-cjs/behavior.core.cjs"), getRandomValues = require("get-random-values-esm"), blockTools = require("@sanity/block-tools");
+var schema = require("@sanity/schema"), types = require("@sanity/types"), startCase = require("lodash.startcase"), jsxRuntime = require("react/jsx-runtime"), react = require("@xstate/react"), isEqual = require("lodash/isEqual.js"), noop = require("lodash/noop.js"), React = require("react"), slate = require("slate"), slateReact = require("slate-react"), debug$l = require("debug"), reactCompilerRuntime = require("react-compiler-runtime"), styledComponents = require("styled-components"), uniq = require("lodash/uniq.js"), rxjs = require("rxjs"), useEffectEvent = require("use-effect-event"), xstate = require("xstate"), patches = require("@portabletext/patches"), flatten = require("lodash/flatten.js"), isPlainObject = require("lodash/isPlainObject.js"), get = require("lodash/get.js"), isUndefined = require("lodash/isUndefined.js"), omitBy = require("lodash/omitBy.js"), selector_isSelectionCollapsed = require("./_chunks-cjs/selector.is-selection-collapsed.cjs"), behavior_core = require("./_chunks-cjs/behavior.core.cjs"), getRandomValues = require("get-random-values-esm"), blockTools = require("@sanity/block-tools");
 function _interopDefaultCompat(e) {
   return e && typeof e == "object" && "default" in e ? e : { default: e };
 }
-var startCase__default = /* @__PURE__ */ _interopDefaultCompat(startCase), isEqual__default = /* @__PURE__ */ _interopDefaultCompat(isEqual), noop__default = /* @__PURE__ */ _interopDefaultCompat(noop), React__default = /* @__PURE__ */ _interopDefaultCompat(React), debug__default = /* @__PURE__ */ _interopDefaultCompat(debug$m), uniq__default = /* @__PURE__ */ _interopDefaultCompat(uniq), flatten__default = /* @__PURE__ */ _interopDefaultCompat(flatten), isPlainObject__default = /* @__PURE__ */ _interopDefaultCompat(isPlainObject), get__default = /* @__PURE__ */ _interopDefaultCompat(get), isUndefined__default = /* @__PURE__ */ _interopDefaultCompat(isUndefined), omitBy__default = /* @__PURE__ */ _interopDefaultCompat(omitBy), getRandomValues__default = /* @__PURE__ */ _interopDefaultCompat(getRandomValues);
+var startCase__default = /* @__PURE__ */ _interopDefaultCompat(startCase), isEqual__default = /* @__PURE__ */ _interopDefaultCompat(isEqual), noop__default = /* @__PURE__ */ _interopDefaultCompat(noop), React__default = /* @__PURE__ */ _interopDefaultCompat(React), debug__default = /* @__PURE__ */ _interopDefaultCompat(debug$l), uniq__default = /* @__PURE__ */ _interopDefaultCompat(uniq), flatten__default = /* @__PURE__ */ _interopDefaultCompat(flatten), isPlainObject__default = /* @__PURE__ */ _interopDefaultCompat(isPlainObject), get__default = /* @__PURE__ */ _interopDefaultCompat(get), isUndefined__default = /* @__PURE__ */ _interopDefaultCompat(isUndefined), omitBy__default = /* @__PURE__ */ _interopDefaultCompat(omitBy), getRandomValues__default = /* @__PURE__ */ _interopDefaultCompat(getRandomValues);
 function createEditorSchema(portableTextType) {
   var _a, _b, _c;
   if (!portableTextType)
@@ -155,7 +155,7 @@ function compileSchemaDefinition(definition) {
   });
 }
 const rootName = "sanity-pte:";
-var debug$l = debug__default.default(rootName);
+debug__default.default(rootName);
 function debugWithName(name) {
   const namespace = `${rootName}${name}`;
   return debug__default.default && debug__default.default.enabled(namespace) ? debug__default.default(namespace) : debug__default.default(rootName);
@@ -2262,6 +2262,19 @@ function findOperationTargetBlock(editor, operation) {
   let block;
   return operation.type === "set_selection" && editor.selection ? block = editor.children[editor.selection.focus.path[0]] : "path" in operation && (block = editor.children[operation.path[0]]), block;
 }
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name), __await = function(promise, isYieldStar) {
+  this[0] = promise, this[1] = isYieldStar;
+}, __asyncGenerator = (__this, __arguments, generator) => {
+  var resume = (k, v, yes, no) => {
+    try {
+      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
+      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
+    } catch (e) {
+      no(e);
+    }
+  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
+  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
+}, __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
 const syncValueCallback = ({
   sendBack,
   input
@@ -2270,7 +2283,8 @@ const syncValueCallback = ({
     context: input.context,
     sendBack,
     slateEditor: input.slateEditor,
-    value: input.value
+    value: input.value,
+    streamBlocks: input.streamBlocks
   });
 }, syncValueLogic = xstate.fromCallback(syncValueCallback), syncMachine = xstate.setup({
   types: {
@@ -2280,6 +2294,9 @@ const syncValueCallback = ({
     emitted: {}
   },
   actions: {
+    "assign initial value synced": xstate.assign({
+      initialValueSynced: !0
+    }),
     "assign readOnly": xstate.assign({
       readOnly: ({
         event
@@ -2298,24 +2315,20 @@ const syncValueCallback = ({
         event
       }) => (xstate.assertEvent(event, "done syncing"), event.value)
     }),
-    "emit done syncing": xstate.emit(({
-      event
-    }) => (xstate.assertEvent(event, "done syncing"), event))
+    "emit done syncing initial value": xstate.emit({
+      type: "done syncing initial value"
+    })
   },
   guards: {
-    "is readOnly": ({
+    "initial value synced": ({
       context
-    }) => context.readOnly,
-    "is processing local changes": ({
-      context
-    }) => context.isProcessingLocalChanges,
-    "is processing remote changes": ({
+    }) => context.initialValueSynced,
+    "is busy": ({
       context
     }) => {
       var _a;
-      return (_a = isChangingRemotely(context.slateEditor)) != null ? _a : !1;
+      return !context.readOnly && (context.isProcessingLocalChanges || ((_a = isChangingRemotely(context.slateEditor)) != null ? _a : !1));
     },
-    "is busy": xstate.and([xstate.not("is readOnly"), xstate.or(["is processing local changes", "is processing remote changes"])]),
     "value changed while syncing": ({
       context,
       event
@@ -2332,6 +2345,7 @@ const syncValueCallback = ({
   context: ({
     input
   }) => ({
+    initialValueSynced: !1,
     isProcessingLocalChanges: !1,
     keyGenerator: input.keyGenerator,
     schema: input.schema,
@@ -2340,7 +2354,6 @@ const syncValueCallback = ({
     pendingValue: void 0,
     previousValue: void 0
   }),
-  initial: "idle",
   on: {
     "has pending patches": {
       actions: xstate.assign({
@@ -2356,101 +2369,114 @@ const syncValueCallback = ({
       actions: ["assign readOnly"]
     }
   },
+  type: "parallel",
   states: {
-    idle: {
-      on: {
-        "update value": [{
-          guard: "is busy",
-          target: "busy",
-          actions: ["assign pending value"]
-        }, {
-          target: "syncing",
-          actions: ["assign pending value"]
-        }]
-      }
-    },
-    busy: {
-      after: {
-        1e3: {
-          target: "syncing"
+    "setting up": {
+      initial: "syncing initial value",
+      states: {
+        "syncing initial value": {
+          always: {
+            guard: "initial value synced",
+            target: "done syncing initial value"
+          }
+        },
+        "done syncing initial value": {
+          entry: ["emit done syncing initial value"],
+          type: "final"
         }
-      },
-      on: {
-        "update value": [{
-          guard: "is busy",
-          actions: ["assign pending value"],
-          reenter: !0
-        }, {
-          target: "syncing",
-          actions: ["assign pending value"]
-        }]
       }
     },
     syncing: {
-      invoke: {
-        src: "sync value",
-        id: "sync value",
-        input: ({
-          context
-        }) => {
-          var _a;
-          return {
-            context: {
-              keyGenerator: context.keyGenerator,
-              previousValue: context.previousValue,
-              readOnly: context.readOnly,
-              schema: context.schema
-            },
-            slateEditor: context.slateEditor,
-            value: (_a = context.pendingValue) != null ? _a : void 0
-          };
-        }
-      },
-      always: {
-        guard: "pending value equals previous value",
-        actions: [xstate.emit(({
-          context
-        }) => ({
-          type: "done syncing",
-          value: context.previousValue
-        }))],
-        target: "idle"
-      },
-      on: {
-        "update value": {
-          actions: ["assign pending value"]
-        },
-        patch: {
-          actions: [xstate.emit(({
-            event
-          }) => event)]
-        },
-        "invalid value": {
-          actions: [xstate.emit(({
-            event
-          }) => event)]
+      initial: "idle",
+      states: {
+        idle: {
+          on: {
+            "update value": [{
+              guard: "is busy",
+              target: "busy",
+              actions: ["assign pending value"]
+            }, {
+              target: "syncing",
+              actions: ["assign pending value"]
+            }]
+          }
         },
-        "value changed": {
-          actions: [xstate.emit(({
-            event
-          }) => event)]
+        busy: {
+          after: {
+            1e3: [{
+              guard: "is busy",
+              reenter: !0
+            }, {
+              target: "syncing"
+            }]
+          },
+          on: {
+            "update value": [{
+              actions: ["assign pending value"]
+            }]
+          }
         },
-        "done syncing": [{
-          guard: "value changed while syncing",
-          actions: ["assign previous value", "emit done syncing"],
-          reenter: !0
-        }, {
-          target: "idle",
-          actions: ["clear pending value", "assign previous value", "emit done syncing"]
-        }]
+        syncing: {
+          always: {
+            guard: "pending value equals previous value",
+            target: "idle",
+            actions: ["clear pending value", "assign initial value synced"]
+          },
+          invoke: {
+            src: "sync value",
+            id: "sync value",
+            input: ({
+              context
+            }) => ({
+              context: {
+                keyGenerator: context.keyGenerator,
+                previousValue: context.previousValue,
+                readOnly: context.readOnly,
+                schema: context.schema
+              },
+              slateEditor: context.slateEditor,
+              streamBlocks: !context.initialValueSynced,
+              value: context.pendingValue
+            })
+          },
+          on: {
+            "update value": {
+              actions: ["assign pending value"]
+            },
+            patch: {
+              actions: [xstate.emit(({
+                event
+              }) => event)]
+            },
+            "invalid value": {
+              actions: [xstate.emit(({
+                event
+              }) => event)]
+            },
+            "value changed": {
+              actions: [xstate.emit(({
+                event
+              }) => event)]
+            },
+            "done syncing": [{
+              guard: "value changed while syncing",
+              actions: ["assign previous value", "assign initial value synced"],
+              reenter: !0
+            }, {
+              target: "idle",
+              actions: ["clear pending value", "assign previous value", "assign initial value synced"]
+            }]
+          }
+        }
       }
     }
   }
 }), debug$i = debugWithName("hook:useSyncValue");
-function updateValue({
+async function updateValue({
   context,
   sendBack,
   slateEditor,
+  streamBlocks,
   value
 }) {
   let isChanged = !1, isValid = !0;
@@ -2475,31 +2501,48 @@ function updateValue({
     const slateValueFromProps = toSlateValue(value, {
       schemaTypes: context.schema
     });
-    slate.Editor.withoutNormalizing(slateEditor, () => {
-      withRemoteChanges(slateEditor, () => {
-        withoutPatching(slateEditor, () => {
-          const childrenLength = slateEditor.children.length;
-          if (slateValueFromProps.length < childrenLength) {
-            for (let i = childrenLength - 1; i > slateValueFromProps.length - 1; i--)
-              slate.Transforms.removeNodes(slateEditor, {
-                at: [i]
-              });
-            isChanged = !0;
-          }
-          for (const [currentBlockIndex, currentBlock] of slateValueFromProps.entries()) {
-            const {
-              blockChanged,
-              blockValid
-            } = syncBlock({
-              context,
-              sendBack,
-              block: currentBlock,
-              index: currentBlockIndex,
-              slateEditor,
-              value
-            });
-            isChanged = blockChanged || isChanged, isValid = isValid && blockValid;
-          }
+    await new Promise((resolve) => {
+      slate.Editor.withoutNormalizing(slateEditor, () => {
+        withRemoteChanges(slateEditor, () => {
+          withoutPatching(slateEditor, async () => {
+            const childrenLength = slateEditor.children.length;
+            if (slateValueFromProps.length < childrenLength) {
+              for (let i = childrenLength - 1; i > slateValueFromProps.length - 1; i--)
+                slate.Transforms.removeNodes(slateEditor, {
+                  at: [i]
+                });
+              isChanged = !0;
+            }
+            try {
+              for (var iter = __forAwait(getBlocks({
+                slateValue: slateValueFromProps,
+                streamBlocks
+              })), more, temp, error; more = !(temp = await iter.next()).done; more = !1) {
+                const [currentBlock, currentBlockIndex] = temp.value, {
+                  blockChanged,
+                  blockValid
+                } = syncBlock({
+                  context,
+                  sendBack,
+                  block: currentBlock,
+                  index: currentBlockIndex,
+                  slateEditor,
+                  value
+                });
+                isChanged = blockChanged || isChanged, isValid = isValid && blockValid;
+              }
+            } catch (temp2) {
+              error = [temp2];
+            } finally {
+              try {
+                more && (temp = iter.return) && await temp.call(iter);
+              } finally {
+                if (error)
+                  throw error[0];
+              }
+            }
+            resolve();
+          });
         });
       });
     });
@@ -2546,6 +2589,29 @@ function updateValue({
     value
   });
 }
+function getBlocks(_0) {
+  return __asyncGenerator(this, arguments, function* ({
+    slateValue,
+    streamBlocks
+  }) {
+    let index = 0;
+    try {
+      for (var iter = __forAwait(slateValue), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = !1) {
+        const block = temp.value;
+        streamBlocks && (yield new __await(new Promise((resolve) => setTimeout(resolve, 0)))), yield [block, index], index++;
+      }
+    } catch (temp2) {
+      error = [temp2];
+    } finally {
+      try {
+        more && (temp = iter.return) && (yield new __await(temp.call(iter)));
+      } finally {
+        if (error)
+          throw error[0];
+      }
+    }
+  });
+}
 function syncBlock({
   context,
   sendBack,
@@ -2554,33 +2620,38 @@ function syncBlock({
   slateEditor,
   value
 }) {
-  var _a, _b, _c, _d, _e;
   let blockChanged = !1, blockValid = !0;
-  const currentBlock = block, currentBlockIndex = index, oldBlock = slateEditor.children[currentBlockIndex];
-  if (oldBlock && !isEqual__default.default(currentBlock, oldBlock) && blockValid) {
-    const validationValue = [value[currentBlockIndex]], validation = validateValue(validationValue, context.schema, context.keyGenerator);
-    !validation.valid && (_a = validation.resolution) != null && _a.autoResolve && ((_b = validation.resolution) == null ? void 0 : _b.patches.length) > 0 && !context.readOnly && context.previousValue && context.previousValue !== value && (console.warn(`${validation.resolution.action} for block with _key '${validationValue[0]._key}'. ${(_c = validation.resolution) == null ? void 0 : _c.description}`), validation.resolution.patches.forEach((patch) => {
-      sendBack({
-        type: "patch",
-        patch
+  const currentBlock = block, currentBlockIndex = index, oldBlock = slateEditor.children[currentBlockIndex], hasChanges = oldBlock && !isEqual__default.default(currentBlock, oldBlock);
+  return slate.Editor.withoutNormalizing(slateEditor, () => {
+    withRemoteChanges(slateEditor, () => {
+      withoutPatching(slateEditor, () => {
+        var _a, _b, _c, _d, _e;
+        if (hasChanges && blockValid) {
+          const validationValue = [value[currentBlockIndex]], validation = validateValue(validationValue, context.schema, context.keyGenerator);
+          !validation.valid && (_a = validation.resolution) != null && _a.autoResolve && ((_b = validation.resolution) == null ? void 0 : _b.patches.length) > 0 && !context.readOnly && context.previousValue && context.previousValue !== value && (console.warn(`${validation.resolution.action} for block with _key '${validationValue[0]._key}'. ${(_c = validation.resolution) == null ? void 0 : _c.description}`), validation.resolution.patches.forEach((patch) => {
+            sendBack({
+              type: "patch",
+              patch
+            });
+          })), validation.valid || (_d = validation.resolution) != null && _d.autoResolve ? (oldBlock._key === currentBlock._key ? (debug$i.enabled && debug$i("Updating block", oldBlock, currentBlock), _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex)) : (debug$i.enabled && debug$i("Replacing block", oldBlock, currentBlock), _replaceBlock(slateEditor, currentBlock, currentBlockIndex)), blockChanged = !0) : (sendBack({
+            type: "invalid value",
+            resolution: validation.resolution,
+            value
+          }), blockValid = !1);
+        }
+        if (!oldBlock && blockValid) {
+          const validationValue = [value[currentBlockIndex]], validation = validateValue(validationValue, context.schema, context.keyGenerator);
+          debug$i.enabled && debug$i("Validating and inserting new block in the end of the value", currentBlock), validation.valid || (_e = validation.resolution) != null && _e.autoResolve ? slate.Transforms.insertNodes(slateEditor, currentBlock, {
+            at: [currentBlockIndex]
+          }) : (debug$i("Invalid", validation), sendBack({
+            type: "invalid value",
+            resolution: validation.resolution,
+            value
+          }), blockValid = !1);
+        }
       });
-    })), validation.valid || (_d = validation.resolution) != null && _d.autoResolve ? (oldBlock._key === currentBlock._key ? (debug$i.enabled && debug$i("Updating block", oldBlock, currentBlock), _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex)) : (debug$i.enabled && debug$i("Replacing block", oldBlock, currentBlock), _replaceBlock(slateEditor, currentBlock, currentBlockIndex)), blockChanged = !0) : (sendBack({
-      type: "invalid value",
-      resolution: validation.resolution,
-      value
-    }), blockValid = !1);
-  }
-  if (!oldBlock && blockValid) {
-    const validationValue = [value[currentBlockIndex]], validation = validateValue(validationValue, context.schema, context.keyGenerator);
-    debug$i.enabled && debug$i("Validating and inserting new block in the end of the value", currentBlock), validation.valid || (_e = validation.resolution) != null && _e.autoResolve ? slate.Transforms.insertNodes(slateEditor, currentBlock, {
-      at: [currentBlockIndex]
-    }) : (debug$i("Invalid", validation), sendBack({
-      type: "invalid value",
-      resolution: validation.resolution,
-      value
-    }), blockValid = !1);
-  }
-  return {
+    });
+  }), {
     blockChanged,
     blockValid
   };
@@ -5639,7 +5710,7 @@ function performAction({
   context,
   action
 }) {
-  switch (debug$l("Behavior action", action), action.type) {
+  switch (action.type) {
     case "delete.block": {
       behaviorActionImplementations["delete.block"]({
         context,
@@ -5978,7 +6049,7 @@ const editorMachine = xstate.setup({
       enqueue
     }) => {
       var _a;
-      xstate.assertEvent(event, ["behavior event"]), debug$l("Behavior event", event);
+      xstate.assertEvent(event, ["behavior event"]);
       const defaultAction = event.behaviorEvent.type === "copy" || event.behaviorEvent.type === "key.down" || event.behaviorEvent.type === "key.up" || event.behaviorEvent.type === "paste" ? void 0 : __spreadProps$4(__spreadValues$4({}, event.behaviorEvent), {
         editor: event.editor
       }), eventBehaviors = context.behaviors.filter((behavior) => behavior.on === event.behaviorEvent.type);
@@ -6166,7 +6237,7 @@ const editorMachine = xstate.setup({
           states: {
             "determine initial edit mode": {
               on: {
-                "done syncing": [{
+                "done syncing initial value": [{
                   target: "#editor.edit mode.read only.read only",
                   guard: ({
                     context
@@ -6262,7 +6333,7 @@ const editorMachine = xstate.setup({
             mutation: {
               actions: "defer event"
             },
-            "done syncing": {
+            "done syncing initial value": {
               target: "pristine"
             }
           }