@portabletext/editor 1.47.14 → 1.48.0

package/src/editor/with-applying-behavior-actions.ts

@@ -19,29 +19,27 @@ export function isApplyingBehaviorActions(editor: Editor) {
 
 ////////
 
-const CURRENT_BEHAVIOR_ACTION_SET: WeakMap<
-  Editor,
-  {actionSetId: string} | undefined
-> = new WeakMap()
+const CURRENT_UNDO_STEP: WeakMap<Editor, {undoStepId: string} | undefined> =
+  new WeakMap()
 
-export function withApplyingBehaviorActionSet(editor: Editor, fn: () => void) {
-  const current = CURRENT_BEHAVIOR_ACTION_SET.get(editor)
+export function withUndoStep(editor: Editor, fn: () => void) {
+  const current = CURRENT_UNDO_STEP.get(editor)
 
   if (current) {
     fn()
     return
   }
 
-  CURRENT_BEHAVIOR_ACTION_SET.set(
+  CURRENT_UNDO_STEP.set(
     editor,
     current ?? {
-      actionSetId: defaultKeyGenerator(),
+      undoStepId: defaultKeyGenerator(),
     },
   )
   fn()
-  CURRENT_BEHAVIOR_ACTION_SET.set(editor, undefined)
+  CURRENT_UNDO_STEP.set(editor, undefined)
 }
 
-export function getCurrentBehaviorActionSetId(editor: Editor) {
-  return CURRENT_BEHAVIOR_ACTION_SET.get(editor)?.actionSetId
+export function getCurrentUndoStepId(editor: Editor) {
+  return CURRENT_UNDO_STEP.get(editor)?.undoStepId
 }

package/src/internal-utils/global-scope.ts

@@ -0,0 +1,19 @@
+/**
+ * Gets the global scope instance in a given environment.
+ *
+ * The strategy is to return the most modern, and if not, the most common:
+ * - The `globalThis` variable is the modern approach to accessing the global scope
+ * - The `window` variable is the global scope in a web browser
+ * - The `self` variable is the global scope in workers and others
+ * - The `global` variable is the global scope in Node.js
+ */
+function getGlobalScope() {
+  if (typeof globalThis !== 'undefined') return globalThis
+  if (typeof window !== 'undefined') return window
+  if (typeof self !== 'undefined') return self
+  if (typeof global !== 'undefined') return global
+
+  throw new Error('@portabletext/editor: could not locate global scope')
+}
+
+export const globalScope = getGlobalScope() as any

package/src/internal-utils/globally-scoped-context.ts

@@ -0,0 +1,39 @@
+import {createContext, type Context} from 'react'
+import {globalScope} from './global-scope'
+
+/**
+ * As `@portabletext/editor` is declared as a dependency, and may be
+ * duplicated, sometimes across major versions it's critical that vital
+ * React Contexts are shared even when there is a duplicate.
+ *
+ * We have to support a Sanity Plugin being able to call hooks like
+ * `useEditor`, and then read the context setup by `sanity`, which calls
+ * `EditorProvider`, even if the provider and hook are different instances in
+ * memory.
+ *
+ * For this reason it's vital that all changes to globally scoped providers
+ * remain fully backwards compatible.
+ */
+export function createGloballyScopedContext<
+  ContextType,
+  const T extends ContextType = ContextType,
+>(
+  /**
+   * Enforce that all Symbol.for keys used for globally scoped contexts have a predictable prefix
+   */
+  key: `@portabletext/editor/context/${string}`,
+  defaultValue: T,
+): Context<ContextType> {
+  const symbol = Symbol.for(key)
+
+  /**
+   * Prevent errors about re-renders on React SSR on Next.js App Router
+   */
+  if (typeof document === 'undefined') {
+    return createContext<ContextType>(defaultValue)
+  }
+
+  globalScope[symbol] = globalScope[symbol] ?? createContext<T>(defaultValue)
+
+  return globalScope[symbol]
+}

package/src/plugins/plugin.decorator-shortcut.ts

@@ -8,7 +8,7 @@ import {
   type CallbackLogicFunction,
 } from 'xstate'
 import {createDecoratorPairBehavior} from '../behaviors/behavior.decorator-pair'
-import {effect, execute} from '../behaviors/behavior.types.action'
+import {effect, execute, forward} from '../behaviors/behavior.types.action'
 import {defineBehavior} from '../behaviors/behavior.types.behavior'
 import type {Editor} from '../editor/create-editor'
 import {useEditor} from '../editor/editor-provider'
@@ -108,13 +108,14 @@ const selectionListenerCallback: CallbackLogicFunction<
         }
       },
       actions: [
-        (_, {blockOffsets}) => [
+        ({event}, {blockOffsets}) => [
           {
             type: 'effect',
             effect: () => {
               sendBack({type: 'selection', blockOffsets})
             },
           },
+          forward(event),
         ],
       ],
     }),

package/src/plugins/plugin.one-line.tsx

@@ -21,7 +21,7 @@ const oneLineBehaviors = [
    */
   defineBehavior({
     on: 'insert.break',
-    actions: [() => [{type: 'noop'}]],
+    actions: [],
   }),
   /**
    * `insert.block` `before` or `after` is not allowed in a one-line editor.
@@ -30,7 +30,7 @@ const oneLineBehaviors = [
     on: 'insert.block',
     guard: ({event}) =>
       event.placement === 'before' || event.placement === 'after',
-    actions: [() => [{type: 'noop'}]],
+    actions: [],
   }),
   /**
    * An ordinary `insert.block` is acceptable if it's a text block. In that
@@ -67,7 +67,7 @@ const oneLineBehaviors = [
    */
   defineBehavior({
     on: 'insert.block',
-    actions: [() => [{type: 'noop'}]],
+    actions: [],
   }),
   /**
    * If multiple blocks are inserted, then the non-text blocks are filtered out

package/src/behavior-actions/behavior.action.noop.ts

@@ -1,5 +0,0 @@
-import type {BehaviorActionImplementation} from './behavior.actions'
-
-export const noopActionImplementation: BehaviorActionImplementation<
-  'noop'
-> = () => {}