@portabletext/editor 3.3.2 → 3.3.4

package/src/internal-utils/debug.ts

@@ -1,12 +0,0 @@
-import debug from 'debug'
-
-const rootName = 'sanity-pte:'
-
-export default debug(rootName)
-export function debugWithName(name: string): debug.Debugger {
-  const namespace = `${rootName}${name}`
-  if (debug && debug.enabled(namespace)) {
-    return debug(namespace)
-  }
-  return debug(rootName)
-}

package/src/internal-utils/editor-selection.test.ts

@@ -1,44 +0,0 @@
-import {compileSchema, defineSchema} from '@portabletext/schema'
-import {expect, test} from 'vitest'
-import {getEditorSelection} from './editor-selection'
-
-test(getEditorSelection.name, () => {
-  const schema = compileSchema(defineSchema({}))
-  const image = {
-    _type: 'image',
-    _key: 'i1',
-  }
-  const splitBlock = {
-    _type: 'block',
-    _key: 'b1',
-    children: [
-      {_type: 'span', _key: 's1', text: 'foo '},
-      {_type: 'span', _key: 's2', text: 'bar'},
-      {_type: 'span', _key: 's3', text: ' baz'},
-    ],
-  }
-  const blockWithStockTicker = {
-    _type: 'block',
-    _key: 'b2',
-    children: [
-      {_type: 'span', _key: 's1', text: ''},
-      {_type: 'stock-ticker', _key: 'st1'},
-      {_type: 'span', _key: 's2', text: ''},
-    ],
-  }
-
-  expect(getEditorSelection({schema, value: [image, splitBlock]})).toEqual({
-    anchor: {path: [{_key: 'i1'}], offset: 0},
-    focus: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 4},
-  })
-  expect(getEditorSelection({schema, value: [splitBlock, image]})).toEqual({
-    anchor: {path: [{_key: 'b1'}, 'children', {_key: 's1'}], offset: 0},
-    focus: {path: [{_key: 'i1'}], offset: 0},
-  })
-  expect(
-    getEditorSelection({schema, value: [blockWithStockTicker, splitBlock]}),
-  ).toEqual({
-    anchor: {path: [{_key: 'b2'}, 'children', {_key: 's1'}], offset: 0},
-    focus: {path: [{_key: 'b1'}, 'children', {_key: 's3'}], offset: 4},
-  })
-})

package/src/internal-utils/editor-selection.ts

@@ -1,56 +0,0 @@
-import {isSpan, isTextBlock} from '@portabletext/schema'
-import type {EditorContext} from '../editor/editor-snapshot'
-import type {EditorSelection, EditorSelectionPoint} from '../types/editor'
-
-export function getEditorSelection(
-  context: Pick<EditorContext, 'schema' | 'value'>,
-): EditorSelection {
-  let anchor: EditorSelectionPoint | undefined
-  let focus: EditorSelectionPoint | undefined
-  const firstBlock = context.value[0]
-  const lastBlock = context.value[context.value.length - 1]
-
-  if (isTextBlock(context, firstBlock)) {
-    anchor = {
-      path: [
-        {_key: firstBlock._key},
-        'children',
-        {_key: firstBlock.children[0]._key},
-      ],
-      offset: 0,
-    }
-  } else {
-    anchor = {
-      path: [{_key: firstBlock._key}],
-      offset: 0,
-    }
-  }
-
-  const lastChild = isTextBlock(context, lastBlock)
-    ? lastBlock.children[lastBlock.children.length - 1]
-    : undefined
-  if (
-    isTextBlock(context, lastBlock) &&
-    lastChild &&
-    isSpan(context, lastChild)
-  ) {
-    focus = {
-      path: [{_key: lastBlock._key}, 'children', {_key: lastChild._key}],
-      offset: lastChild.text.length ?? 0,
-    }
-  } else {
-    focus = {
-      path: [{_key: lastBlock._key}],
-      offset: 0,
-    }
-  }
-
-  if (!anchor || !focus) {
-    throw new Error('No selection found')
-  }
-
-  return {
-    anchor,
-    focus,
-  }
-}

package/src/internal-utils/event-position.ts

@@ -1,318 +0,0 @@
-import {Editor, type BaseRange, type Node} from 'slate'
-import {DOMEditor, isDOMNode} from 'slate-dom'
-import type {EditorActor} from '../editor/editor-machine'
-import type {EditorSchema} from '../editor/editor-schema'
-import type {EditorSelection} from '../types/editor'
-import type {PortableTextSlateEditor} from '../types/slate-editor'
-import {getBlockEndPoint} from '../utils/util.get-block-end-point'
-import {getBlockStartPoint} from '../utils/util.get-block-start-point'
-import {isSelectionCollapsed} from '../utils/util.is-selection-collapsed'
-import {getBlockKeyFromSelectionPoint} from '../utils/util.selection-point'
-import {
-  getFirstBlock,
-  getLastBlock,
-  getNodeBlock,
-  slateRangeToSelection,
-} from './slate-utils'
-
-export type EventPosition = {
-  block: 'start' | 'end'
-  /**
-   * Did the event origin from the editor DOM node itself or from a child node?
-   */
-  isEditor: boolean
-  selection: NonNullable<EditorSelection>
-}
-export type EventPositionBlock = EventPosition['block']
-
-export function getEventPosition({
-  editorActor,
-  slateEditor,
-  event,
-}: {
-  editorActor: EditorActor
-  slateEditor: PortableTextSlateEditor
-  event: DragEvent | MouseEvent
-}): EventPosition | undefined {
-  if (editorActor.getSnapshot().matches({setup: 'setting up'})) {
-    return undefined
-  }
-
-  const eventNode = getEventNode({slateEditor, event})
-
-  if (!eventNode) {
-    return undefined
-  }
-
-  const eventBlock = getNodeBlock({
-    editor: slateEditor,
-    schema: editorActor.getSnapshot().context.schema,
-    node: eventNode,
-  })
-  const eventPositionBlock = getEventPositionBlock({
-    node: eventNode,
-    slateEditor,
-    event,
-  })
-  const eventSelection = getEventSelection({
-    schema: editorActor.getSnapshot().context.schema,
-    slateEditor,
-    event,
-  })
-
-  if (
-    eventBlock &&
-    eventPositionBlock &&
-    !eventSelection &&
-    !Editor.isEditor(eventNode)
-  ) {
-    // If we for some reason can't find the event selection, then we default to
-    // selecting the entire block that the event originates from.
-    return {
-      block: eventPositionBlock,
-      isEditor: false,
-      selection: {
-        anchor: getBlockStartPoint({
-          context: editorActor.getSnapshot().context,
-          block: {
-            node: eventBlock,
-            path: [{_key: eventBlock._key}],
-          },
-        }),
-        focus: getBlockEndPoint({
-          context: editorActor.getSnapshot().context,
-          block: {
-            node: eventBlock,
-            path: [{_key: eventBlock._key}],
-          },
-        }),
-      },
-    }
-  }
-
-  if (!eventPositionBlock || !eventSelection) {
-    return undefined
-  }
-
-  const eventSelectionFocusBlockKey = getBlockKeyFromSelectionPoint(
-    eventSelection.focus,
-  )
-
-  if (eventSelectionFocusBlockKey === undefined) {
-    return undefined
-  }
-
-  if (
-    isSelectionCollapsed(eventSelection) &&
-    eventBlock &&
-    eventSelectionFocusBlockKey !== eventBlock._key
-  ) {
-    // If the event block and event selection somehow don't match, then the
-    // event block takes precedence.
-    return {
-      block: eventPositionBlock,
-      isEditor: false,
-      selection: {
-        anchor: getBlockStartPoint({
-          context: editorActor.getSnapshot().context,
-          block: {
-            node: eventBlock,
-            path: [{_key: eventBlock._key}],
-          },
-        }),
-        focus: getBlockEndPoint({
-          context: editorActor.getSnapshot().context,
-          block: {
-            node: eventBlock,
-            path: [{_key: eventBlock._key}],
-          },
-        }),
-      },
-    }
-  }
-
-  return {
-    block: eventPositionBlock,
-    isEditor: Editor.isEditor(eventNode),
-    selection: eventSelection,
-  }
-}
-
-export function getEventNode({
-  slateEditor,
-  event,
-}: {
-  slateEditor: PortableTextSlateEditor
-  event: DragEvent | MouseEvent
-}) {
-  if (!DOMEditor.hasTarget(slateEditor, event.target)) {
-    return undefined
-  }
-
-  let node: Node | undefined
-
-  try {
-    node = DOMEditor.toSlateNode(slateEditor, event.target)
-  } catch (error) {
-    console.error(error)
-  }
-
-  return node
-}
-
-function getEventPositionBlock({
-  node,
-  slateEditor,
-  event,
-}: {
-  node: Node
-  slateEditor: PortableTextSlateEditor
-  event: DragEvent | MouseEvent
-}): EventPositionBlock | undefined {
-  const [firstBlock] = getFirstBlock({editor: slateEditor})
-
-  if (!firstBlock) {
-    return undefined
-  }
-
-  let firstBlockElement: HTMLElement | undefined
-
-  try {
-    firstBlockElement = DOMEditor.toDOMNode(slateEditor, firstBlock)
-  } catch (error) {
-    console.error(error)
-  }
-
-  if (!firstBlockElement) {
-    return undefined
-  }
-
-  const firstBlockRect = firstBlockElement.getBoundingClientRect()
-
-  if (event.pageY < firstBlockRect.top) {
-    return 'start'
-  }
-
-  const [lastBlock] = getLastBlock({editor: slateEditor})
-
-  if (!lastBlock) {
-    return undefined
-  }
-
-  let lastBlockElement: HTMLElement | undefined
-
-  try {
-    lastBlockElement = DOMEditor.toDOMNode(slateEditor, lastBlock)
-  } catch (error) {
-    console.error(error)
-  }
-
-  if (!lastBlockElement) {
-    return undefined
-  }
-
-  const lastBlockRef = lastBlockElement.getBoundingClientRect()
-
-  if (event.pageY > lastBlockRef.bottom) {
-    return 'end'
-  }
-
-  let element: HTMLElement | undefined
-
-  try {
-    element = DOMEditor.toDOMNode(slateEditor, node)
-  } catch (error) {
-    console.error(error)
-  }
-
-  if (!element) {
-    return undefined
-  }
-
-  const elementRect = element.getBoundingClientRect()
-  const top = elementRect.top
-  const height = elementRect.height
-  const location = Math.abs(top - event.pageY)
-
-  return location < height / 2 ? 'start' : 'end'
-}
-
-export function getEventSelection({
-  schema,
-  slateEditor,
-  event,
-}: {
-  schema: EditorSchema
-  slateEditor: PortableTextSlateEditor
-  event: DragEvent | MouseEvent
-}): EditorSelection {
-  const range = getSlateRangeFromEvent(slateEditor, event)
-
-  const selection = range
-    ? slateRangeToSelection({
-        schema,
-        editor: slateEditor,
-        range,
-      })
-    : null
-
-  return selection
-}
-
-function getSlateRangeFromEvent(
-  editor: PortableTextSlateEditor,
-  event: DragEvent | MouseEvent,
-) {
-  if (!event.target) {
-    return undefined
-  }
-
-  if (!isDOMNode(event.target)) {
-    return undefined
-  }
-
-  const window = DOMEditor.getWindow(editor)
-
-  let domRange: Range | undefined
-
-  if (window.document.caretPositionFromPoint !== undefined) {
-    const position = window.document.caretPositionFromPoint(
-      event.clientX,
-      event.clientY,
-    )
-
-    if (position) {
-      try {
-        domRange = window.document.createRange()
-        domRange.setStart(position.offsetNode, position.offset)
-        domRange.setEnd(position.offsetNode, position.offset)
-      } catch {}
-    }
-  } else if (window.document.caretRangeFromPoint !== undefined) {
-    // Use WebKit-proprietary fallback method
-    domRange =
-      window.document.caretRangeFromPoint(event.clientX, event.clientY) ??
-      undefined
-  } else {
-    console.warn(
-      'Neither caretPositionFromPoint nor caretRangeFromPoint is supported',
-    )
-    return undefined
-  }
-
-  if (!domRange) {
-    return undefined
-  }
-
-  let range: BaseRange | undefined
-
-  try {
-    range = DOMEditor.toSlateRange(editor, domRange, {
-      exactMatch: false,
-      // It can still throw even with this option set to true
-      suppressThrow: false,
-    })
-  } catch {}
-
-  return range
-}

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

@@ -1,27 +0,0 @@
-/**
- * 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

@@ -1,39 +0,0 @@
-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/internal-utils/is-hotkey.test.ts

@@ -1,114 +0,0 @@
-import {expect, test} from 'vitest'
-import {isHotkey, type KeyboardEventLike} from './is-hotkey'
-
-function e(
-  value: string | number,
-  modifiers: Array<'altKey' | 'ctrlKey' | 'metaKey' | 'shiftKey'> = [],
-) {
-  return {
-    ...(typeof value === 'string' ? {key: value} : {keyCode: value}),
-    altKey: modifiers.includes('altKey'),
-    ctrlKey: modifiers.includes('ctrlKey'),
-    metaKey: modifiers.includes('metaKey'),
-    shiftKey: modifiers.includes('shiftKey'),
-  } as KeyboardEventLike
-}
-
-type TestCase = [string, KeyboardEventLike, boolean]
-
-const testCases: TestCase[] = [
-  ['meta', e('Meta', ['metaKey']), true],
-  ['Meta', e('Meta', ['metaKey']), true],
-  ['meta', e(93, ['metaKey']), true],
-  ['Meta', e(93, ['metaKey']), true],
-
-  ['meta+s', e('s', ['metaKey']), true],
-  ['Meta+S', e('s', ['metaKey']), true],
-  ['meta+s', e(83, ['metaKey']), true],
-  ['Meta+S', e(83, ['metaKey']), true],
-
-  ['cmd+space', e(' ', ['metaKey']), true],
-  ['Cmd+Space', e(' ', ['metaKey']), true],
-  ['cmd+space', e(32, ['metaKey']), true],
-  ['Cmd+Space', e(32, ['metaKey']), true],
-
-  ['cmd+alt?+s', e('s', ['metaKey']), true],
-  ['cmd+alt?+s', e('s', ['metaKey', 'altKey']), true],
-  ['cmd+alt?+s', e(83, ['metaKey']), true],
-  ['cmd+alt?+s', e(83, ['metaKey', 'altKey']), true],
-
-  ['Cmd+Alt?+S', e('s', ['metaKey']), true],
-  ['Cmd+Alt?+S', e('s', ['metaKey', 'altKey']), true],
-  ['Cmd+Alt?+S', e(83, ['metaKey']), true],
-  ['Cmd+Alt?+S', e(83, ['metaKey', 'altKey']), true],
-
-  ['cmd+s', e('s', ['metaKey', 'altKey']), false],
-  ['Cmd+S', e('s', ['metaKey', 'altKey']), false],
-  ['cmd+s', e(83, ['metaKey', 'altKey']), false],
-  ['Cmd+S', e(83, ['metaKey', 'altKey']), false],
-
-  ['cmd+s', e('s', ['metaKey']), true],
-  ['Cmd+s', e('s', ['metaKey']), true],
-  ['cmd+s', e(83, ['metaKey']), true],
-  ['Cmd+s', e(83, ['metaKey']), true],
-
-  ['mod+s', e('s', ['ctrlKey']), true],
-  ['Mod+S', e('s', ['ctrlKey']), true],
-  ['mod+s', e(83, ['ctrlKey']), true],
-  ['Mod+S', e(83, ['ctrlKey']), true],
-
-  ['meta+alt+s', e('s', ['metaKey', 'altKey']), true],
-  ['Meta+Alt+S', e('s', ['metaKey', 'altKey']), true],
-  ['meta+alt+s', e(83, ['metaKey', 'altKey']), true],
-  ['Meta+Alt+S', e(83, ['metaKey', 'altKey']), true],
-
-  ['?', e('?'), true],
-  ['?', e('?', ['altKey']), false],
-
-  ['a', e('a'), true],
-  ['a', e('A'), true],
-  ['A', e('a'), true],
-  ['A', e('A'), true],
-  ['a', e(65), true],
-  ['A', e(65), true],
-
-  ['a', e('a', ['ctrlKey']), false],
-  ['A', e('a', ['ctrlKey']), false],
-  ['a', e(65, ['ctrlKey']), false],
-  ['A', e(65, ['ctrlKey']), false],
-
-  ['shift', e('Shift', ['shiftKey']), true],
-  ['Shift', e('Shift', ['shiftKey']), true],
-  ['shift', e(16, ['shiftKey']), true],
-  ['Shift', e(16, ['shiftKey']), true],
-
-  ['meta+a', e('a', ['metaKey']), true],
-  ['Meta+A', e('a', ['metaKey']), true],
-  ['cmd+a', e(65, ['metaKey']), true],
-  ['Cmd+A', e(65, ['metaKey']), true],
-
-  ['enter', e('Enter'), true],
-  ['Enter', e('Enter'), true],
-  ['enter', e(13), true],
-  ['Enter', e(13), true],
-  ['enter', e('Enter', ['shiftKey']), false],
-  ['Enter', e('Enter', ['shiftKey']), false],
-
-  ['cmd+=', e(187, ['metaKey']), true],
-  ['Cmd+=', e(187, ['metaKey']), true],
-  ['cmd++', e('+', ['metaKey']), true],
-  ['Cmd++', e('+', ['metaKey']), true],
-
-  ['meta+alt+ß', e('ß', ['metaKey', 'altKey']), true],
-  ['Meta+Alt+ß', e('ß', ['metaKey', 'altKey']), true],
-] satisfies Array<TestCase>
-
-test(isHotkey.name, () => {
-  for (const testCase of testCases) {
-    expect(isHotkey(testCase[0], testCase[1])).toBe(testCase[2])
-  }
-
-  expect(() =>
-    isHotkey('ctrlalt+k', e('k', ['ctrlKey', 'altKey'])),
-  ).toThrowError('Unknown modifier: "ctrlalt"')
-})