@portabletext/editor 1.49.8 → 1.49.10

package/src/internal-utils/applyPatch.ts

@@ -24,16 +24,16 @@ import type {
 } from '@sanity/types'
 import {
   Element,
+  Node,
   Text,
   Transforms,
   type Descendant,
-  type Node,
   type Path as SlatePath,
 } from 'slate'
 import type {EditorSchema} from '../editor/editor-schema'
 import type {PortableTextSlateEditor} from '../types/editor'
 import {debugWithName} from './debug'
-import {toSlateValue} from './values'
+import {isEqualToEmptyEditor, toSlateValue} from './values'
 import {KEY_TO_SLATE_ELEMENT} from './weakMaps'
 
 const debug = debugWithName('applyPatches')
@@ -173,9 +173,24 @@ function insertPatch(
     const targetBlockIndex = targetBlockPath[0]
     const normalizedIdx =
       position === 'after' ? targetBlockIndex + 1 : targetBlockIndex
+
     debug(`Inserting blocks at path [${normalizedIdx}]`)
     debugState(editor, 'before')
+
+    const editorWasEmptyBefore = isEqualToEmptyEditor(editor.children, schema)
+
     Transforms.insertNodes(editor, blocksToInsert, {at: [normalizedIdx]})
+
+    if (
+      editorWasEmptyBefore &&
+      typeof patch.path[0] === 'number' &&
+      patch.path[0] === 0
+    ) {
+      Transforms.removeNodes(editor, {
+        at: [position === 'before' ? targetBlockIndex + 1 : targetBlockIndex],
+      })
+    }
+
     debugState(editor, 'after')
     return true
   }
@@ -319,9 +334,15 @@ function unsetPatch(editor: PortableTextSlateEditor, patch: UnsetPatch) {
     debugState(editor, 'before')
     const previousSelection = editor.selection
     Transforms.deselect(editor)
-    editor.children.forEach((_child, i) => {
-      Transforms.removeNodes(editor, {at: [i]})
+
+    const children = Node.children(editor, [], {
+      reverse: true,
     })
+
+    for (const [_, path] of children) {
+      Transforms.removeNodes(editor, {at: path})
+    }
+
     Transforms.insertNodes(editor, editor.pteCreateTextBlock({decorators: []}))
     if (previousSelection) {
       Transforms.select(editor, {

package/src/internal-utils/stop-actor.ts

@@ -0,0 +1,43 @@
+/**
+ * Copy/pasted from https://github.com/statelyai/xstate/blob/main/packages/xstate-react/src/stopRootWithRehydration.ts
+ * and renamed to `stopActor`
+ */
+
+import type {AnyActorRef, Snapshot} from 'xstate'
+
+const forEachActor = (
+  actorRef: AnyActorRef,
+  callback: (ref: AnyActorRef) => void,
+) => {
+  callback(actorRef)
+  const children = actorRef.getSnapshot().children
+  if (children) {
+    Object.values(children).forEach((child) => {
+      forEachActor(child as AnyActorRef, callback)
+    })
+  }
+}
+
+export function stopActor(actorRef: AnyActorRef) {
+  // persist snapshot here in a custom way allows us to persist inline actors and to preserve actor references
+  // we do it to avoid setState in useEffect when the effect gets "reconnected"
+  // this currently only happens in Strict Effects but it simulates the Offscreen aka Activity API
+  // it also just allows us to end up with a somewhat more predictable behavior for the users
+  const persistedSnapshots: Array<[AnyActorRef, Snapshot<unknown>]> = []
+  forEachActor(actorRef, (ref) => {
+    persistedSnapshots.push([ref, ref.getSnapshot()])
+    // muting observers allow us to avoid `useSelector` from being notified about the stopped snapshot
+    // React reconnects its subscribers (from the useSyncExternalStore) on its own
+    // and userland subscibers should basically always do the same anyway
+    // as each subscription should have its own cleanup logic and that should be called each such reconnect
+    ;(ref as any).observers = new Set()
+  })
+  const systemSnapshot = actorRef.system.getSnapshot?.()
+
+  actorRef.stop()
+  ;(actorRef.system as any)._snapshot = systemSnapshot
+  persistedSnapshots.forEach(([ref, snapshot]) => {
+    ;(ref as any)._processingStatus = 0
+    ;(ref as any)._snapshot = snapshot
+  })
+}

package/src/internal-utils/use-constant.ts

@@ -0,0 +1,15 @@
+import React from 'react'
+
+type ConstantRef<TConstant> = {constant: TConstant}
+
+export default function useConstant<TConstant>(
+  factory: () => TConstant,
+): TConstant {
+  const ref = React.useRef<ConstantRef<TConstant>>(null)
+
+  if (!ref.current) {
+    ref.current = {constant: factory()}
+  }
+
+  return ref.current.constant
+}