@portabletext/editor 1.16.1 → 1.16.3

package/lib/index.js

@@ -19,13 +19,13 @@ import noop from "lodash/noop.js";
 import React, { useRef, useState, useEffect, useMemo, createContext, useContext, startTransition, Component, useCallback, forwardRef, useImperativeHandle } from "react";
 import { Editor, Element as Element$1, Range, Point, Text, Path, Transforms, Operation, Node, createEditor as createEditor$1, deleteBackward, deleteForward, insertText } from "slate";
 import { useSlateStatic, ReactEditor, useSelected, withReact, Slate, useSlate, Editable } from "slate-react";
-import debug$m from "debug";
+import debug$l from "debug";
 import { c } from "react-compiler-runtime";
 import { styled } from "styled-components";
 import uniq from "lodash/uniq.js";
 import { Subject } from "rxjs";
 import { useEffectEvent } from "use-effect-event";
-import { setup, emit, assign, fromCallback, assertEvent, and, not, or, enqueueActions, createActor } from "xstate";
+import { setup, emit, assign, fromCallback, assertEvent, enqueueActions, createActor } from "xstate";
 import { unset, set, setIfMissing, insert, diffMatchPatch as diffMatchPatch$1, applyAll } from "@portabletext/patches";
 import flatten from "lodash/flatten.js";
 import isPlainObject from "lodash/isPlainObject.js";
@@ -175,10 +175,10 @@ function compileSchemaDefinition(definition) {
   });
 }
 const rootName = "sanity-pte:";
-var debug$l = debug$m(rootName);
+debug$l(rootName);
 function debugWithName(name) {
   const namespace = `${rootName}${name}`;
-  return debug$m && debug$m.enabled(namespace) ? debug$m(namespace) : debug$m(rootName);
+  return debug$l && debug$l.enabled(namespace) ? debug$l(namespace) : debug$l(rootName);
 }
 function createKeyedPath(point, value, types) {
   const blockPath = [point.path[0]];
@@ -2282,6 +2282,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
@@ -2290,7 +2303,8 @@ const syncValueCallback = ({
     context: input.context,
     sendBack,
     slateEditor: input.slateEditor,
-    value: input.value
+    value: input.value,
+    streamBlocks: input.streamBlocks
   });
 }, syncValueLogic = fromCallback(syncValueCallback), syncMachine = setup({
   types: {
@@ -2300,6 +2314,9 @@ const syncValueCallback = ({
     emitted: {}
   },
   actions: {
+    "assign initial value synced": assign({
+      initialValueSynced: !0
+    }),
     "assign readOnly": assign({
       readOnly: ({
         event
@@ -2318,24 +2335,20 @@ const syncValueCallback = ({
         event
       }) => (assertEvent(event, "done syncing"), event.value)
     }),
-    "emit done syncing": emit(({
-      event
-    }) => (assertEvent(event, "done syncing"), event))
+    "emit done syncing initial value": 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": and([not("is readOnly"), or(["is processing local changes", "is processing remote changes"])]),
     "value changed while syncing": ({
       context,
       event
@@ -2352,6 +2365,7 @@ const syncValueCallback = ({
   context: ({
     input
   }) => ({
+    initialValueSynced: !1,
     isProcessingLocalChanges: !1,
     keyGenerator: input.keyGenerator,
     schema: input.schema,
@@ -2360,7 +2374,6 @@ const syncValueCallback = ({
     pendingValue: void 0,
     previousValue: void 0
   }),
-  initial: "idle",
   on: {
     "has pending patches": {
       actions: assign({
@@ -2376,101 +2389,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: [emit(({
-          context
-        }) => ({
-          type: "done syncing",
-          value: context.previousValue
-        }))],
-        target: "idle"
-      },
-      on: {
-        "update value": {
-          actions: ["assign pending value"]
-        },
-        patch: {
-          actions: [emit(({
-            event
-          }) => event)]
-        },
-        "invalid value": {
-          actions: [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: [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: [emit(({
+                event
+              }) => event)]
+            },
+            "invalid value": {
+              actions: [emit(({
+                event
+              }) => event)]
+            },
+            "value changed": {
+              actions: [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;
@@ -2495,31 +2521,48 @@ function updateValue({
     const slateValueFromProps = toSlateValue(value, {
       schemaTypes: context.schema
     });
-    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--)
-              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) => {
+      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--)
+                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();
+          });
         });
       });
     });
@@ -2566,6 +2609,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,
@@ -2574,33 +2640,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(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(currentBlock, oldBlock);
+  return 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 ? 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 ? Transforms.insertNodes(slateEditor, currentBlock, {
-      at: [currentBlockIndex]
-    }) : (debug$i("Invalid", validation), sendBack({
-      type: "invalid value",
-      resolution: validation.resolution,
-      value
-    }), blockValid = !1);
-  }
-  return {
+    });
+  }), {
     blockChanged,
     blockValid
   };
@@ -5659,7 +5730,7 @@ function performAction({
   context,
   action
 }) {
-  switch (debug$l("Behavior action", action), action.type) {
+  switch (action.type) {
     case "delete.block": {
       behaviorActionImplementations["delete.block"]({
         context,
@@ -5998,7 +6069,7 @@ const editorMachine = setup({
       enqueue
     }) => {
       var _a;
-      assertEvent(event, ["behavior event"]), debug$l("Behavior event", event);
+      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);
@@ -6186,7 +6257,7 @@ const editorMachine = setup({
           states: {
             "determine initial edit mode": {
               on: {
-                "done syncing": [{
+                "done syncing initial value": [{
                   target: "#editor.edit mode.read only.read only",
                   guard: ({
                     context
@@ -6282,7 +6353,7 @@ const editorMachine = setup({
             mutation: {
               actions: "defer event"
             },
-            "done syncing": {
+            "done syncing initial value": {
               target: "pristine"
             }
           }