@portabletext/editor 3.3.2 → 3.3.4

package/src/behaviors/behavior.abstract.ts

@@ -1,139 +0,0 @@
-import {getFocusSpan} from '../selectors/selector.get-focus-span'
-import {isSelectionCollapsed} from '../selectors/selector.is-selection-collapsed'
-import {isSelectionExpanded} from '../selectors/selector.is-selection-expanded'
-import {abstractAnnotationBehaviors} from './behavior.abstract.annotation'
-import {abstractDecoratorBehaviors} from './behavior.abstract.decorator'
-import {abstractDeleteBehaviors} from './behavior.abstract.delete'
-import {abstractDeserializeBehaviors} from './behavior.abstract.deserialize'
-import {abstractInsertBehaviors} from './behavior.abstract.insert'
-import {abstractKeyboardBehaviors} from './behavior.abstract.keyboard'
-import {abstractListItemBehaviors} from './behavior.abstract.list-item'
-import {abstractMoveBehaviors} from './behavior.abstract.move'
-import {abstractSelectBehaviors} from './behavior.abstract.select'
-import {abstractSerializeBehaviors} from './behavior.abstract.serialize'
-import {abstractSplitBehaviors} from './behavior.abstract.split'
-import {abstractStyleBehaviors} from './behavior.abstract.style'
-import {raise} from './behavior.types.action'
-import {defineBehavior} from './behavior.types.behavior'
-
-export const abstractBehaviors = [
-  defineBehavior({
-    on: 'clipboard.copy',
-    guard: ({snapshot}) => {
-      const focusSpan = getFocusSpan(snapshot)
-      const selectionCollapsed = isSelectionCollapsed(snapshot)
-
-      return focusSpan && selectionCollapsed
-    },
-    actions: [],
-  }),
-  defineBehavior({
-    on: 'clipboard.copy',
-    actions: [
-      ({event}) => [
-        raise({
-          type: 'serialize',
-          originEvent: event,
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'clipboard.cut',
-    guard: ({snapshot}) => {
-      const focusSpan = getFocusSpan(snapshot)
-      const selectionCollapsed = isSelectionCollapsed(snapshot)
-
-      return focusSpan && selectionCollapsed
-    },
-    actions: [],
-  }),
-  defineBehavior({
-    on: 'clipboard.cut',
-    guard: ({snapshot}) => {
-      return snapshot.context.selection
-        ? {
-            selection: snapshot.context.selection,
-          }
-        : false
-    },
-    actions: [
-      ({event}, {selection}) => [
-        raise({
-          type: 'serialize',
-          originEvent: event,
-        }),
-        raise({
-          type: 'delete',
-          at: selection,
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'drag.dragstart',
-    actions: [
-      ({event}) => [
-        raise({
-          type: 'serialize',
-          originEvent: event,
-        }),
-      ],
-    ],
-  }),
-
-  defineBehavior({
-    on: 'clipboard.paste',
-    guard: ({snapshot}) => {
-      return snapshot.context.selection && isSelectionExpanded(snapshot)
-        ? {selection: snapshot.context.selection}
-        : false
-    },
-    actions: [
-      ({event}, {selection}) => [
-        raise({
-          type: 'delete',
-          at: selection,
-        }),
-        raise({
-          type: 'deserialize',
-          originEvent: event,
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'clipboard.paste',
-    actions: [
-      ({event}) => [
-        raise({
-          type: 'deserialize',
-          originEvent: event,
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'input.*',
-    actions: [
-      ({event}) => [
-        raise({
-          type: 'deserialize',
-          originEvent: event,
-        }),
-      ],
-    ],
-  }),
-  ...abstractAnnotationBehaviors,
-  ...abstractDecoratorBehaviors,
-  ...abstractDeleteBehaviors,
-  ...abstractDeserializeBehaviors,
-  ...abstractInsertBehaviors,
-  ...abstractKeyboardBehaviors,
-  ...abstractListItemBehaviors,
-  ...abstractMoveBehaviors,
-  ...abstractStyleBehaviors,
-  ...abstractSelectBehaviors,
-  ...abstractSerializeBehaviors,
-  ...abstractSplitBehaviors,
-]

package/src/behaviors/behavior.config.ts

@@ -1,7 +0,0 @@
-import type {EditorPriority} from '../priority/priority.types'
-import type {Behavior} from './behavior.types.behavior'
-
-export type BehaviorConfig = {
-  behavior: Behavior
-  priority: EditorPriority
-}

package/src/behaviors/behavior.core.annotations.ts

@@ -1,62 +0,0 @@
-import {getCaretWordSelection} from '../selectors/selector.get-caret-word-selection'
-import {isActiveAnnotation} from '../selectors/selector.is-active-annotation'
-import {isSelectionCollapsed} from '../selectors/selector.is-selection-collapsed'
-import {isSelectionExpanded} from '../selectors/selector.is-selection-expanded'
-import {raise} from './behavior.types.action'
-import {defineBehavior} from './behavior.types.behavior'
-
-const addAnnotationOnCollapsedSelection = defineBehavior({
-  on: 'annotation.add',
-  guard: ({snapshot}) => {
-    if (!isSelectionCollapsed(snapshot)) {
-      return false
-    }
-
-    const caretWordSelection = getCaretWordSelection(snapshot)
-
-    if (
-      !caretWordSelection ||
-      !isSelectionExpanded({
-        ...snapshot,
-        context: {
-          ...snapshot.context,
-          selection: caretWordSelection,
-        },
-      })
-    ) {
-      return false
-    }
-
-    return {caretWordSelection}
-  },
-  actions: [
-    ({event}, {caretWordSelection}) => [
-      raise({type: 'select', at: caretWordSelection}),
-      raise({type: 'annotation.add', annotation: event.annotation}),
-    ],
-  ],
-})
-
-/**
- * By default, same-type annotations can overlap. This Core Behavior ensures
- * that annotations of the same type are mutually exclusive.
- */
-const preventOverlappingAnnotations = defineBehavior({
-  // Given an `annotation.add` event
-  on: 'annotation.add',
-  // When the annotation is active in the selection
-  guard: ({snapshot, event}) =>
-    isActiveAnnotation(event.annotation.name, {mode: 'partial'})(snapshot),
-  // Then the existing annotation is removed
-  actions: [
-    ({event}) => [
-      raise({type: 'annotation.remove', annotation: event.annotation}),
-      raise(event),
-    ],
-  ],
-})
-
-export const coreAnnotationBehaviors = [
-  addAnnotationOnCollapsedSelection,
-  preventOverlappingAnnotations,
-]

package/src/behaviors/behavior.core.block-element.ts

@@ -1,116 +0,0 @@
-import type {EventPositionBlock} from '../internal-utils/event-position'
-import {corePriority} from '../priority/priority.core'
-import {createEditorPriority} from '../priority/priority.types'
-import {getDragSelection} from '../selectors/drag-selection'
-import {getFocusBlock} from '../selectors/selector.get-focus-block'
-import {getSelectedBlocks} from '../selectors/selector.get-selected-blocks'
-import {isSelectingEntireBlocks} from '../selectors/selector.is-selecting-entire-blocks'
-import {forward} from './behavior.types.action'
-import {defineBehavior} from './behavior.types.behavior'
-
-export function createCoreBlockElementBehaviorsConfig({
-  key,
-  onSetDragPositionBlock,
-}: {
-  key: string
-  onSetDragPositionBlock: (
-    eventPositionBlock: EventPositionBlock | undefined,
-  ) => void
-}) {
-  return [
-    {
-      behavior: defineBehavior({
-        on: 'drag.dragover',
-        guard: ({snapshot, event}) => {
-          const dropFocusBlock = getFocusBlock({
-            ...snapshot,
-            context: {
-              ...snapshot.context,
-              selection: event.position.selection,
-            },
-          })
-
-          if (!dropFocusBlock || dropFocusBlock.node._key !== key) {
-            return false
-          }
-
-          const dragOrigin = event.dragOrigin
-
-          if (!dragOrigin) {
-            return false
-          }
-
-          const dragSelection = getDragSelection({
-            eventSelection: dragOrigin.selection,
-            snapshot,
-          })
-
-          const draggedBlocks = getSelectedBlocks({
-            ...snapshot,
-            context: {
-              ...snapshot.context,
-              selection: dragSelection,
-            },
-          })
-
-          if (
-            draggedBlocks.some((draggedBlock) => draggedBlock.node._key === key)
-          ) {
-            return false
-          }
-
-          const draggingEntireBlocks = isSelectingEntireBlocks({
-            ...snapshot,
-            context: {
-              ...snapshot.context,
-              selection: dragSelection,
-            },
-          })
-
-          return draggingEntireBlocks
-        },
-        actions: [
-          ({event}) => [
-            {
-              type: 'effect',
-              effect: () => {
-                onSetDragPositionBlock(event.position.block)
-              },
-            },
-          ],
-        ],
-      }),
-      priority: createEditorPriority({
-        reference: {
-          priority: corePriority,
-          importance: 'lower',
-        },
-      }),
-    },
-    {
-      behavior: defineBehavior({
-        on: 'drag.*',
-        guard: ({event}) => {
-          return event.type !== 'drag.dragover'
-        },
-        actions: [
-          ({event}) => [
-            {
-              type: 'effect',
-              effect: () => {
-                onSetDragPositionBlock(undefined)
-              },
-            },
-            forward(event),
-          ],
-        ],
-      }),
-      priority: createEditorPriority({
-        reference: {
-          priority: corePriority,
-          importance: 'lower',
-        },
-      }),
-    },
-  ]
-}

package/src/behaviors/behavior.core.block-objects.ts

@@ -1,285 +0,0 @@
-import {isTextBlock} from '@portabletext/schema'
-import {defaultKeyboardShortcuts} from '../keyboard-shortcuts/default-keyboard-shortcuts'
-import {getFocusBlockObject} from '../selectors/selector.get-focus-block-object'
-import {getFocusTextBlock} from '../selectors/selector.get-focus-text-block'
-import {getNextBlock} from '../selectors/selector.get-next-block'
-import {getPreviousBlock} from '../selectors/selector.get-previous-block'
-import {isSelectionCollapsed} from '../selectors/selector.is-selection-collapsed'
-import {isEmptyTextBlock} from '../utils/util.is-empty-text-block'
-import {raise} from './behavior.types.action'
-import {defineBehavior} from './behavior.types.behavior'
-
-const arrowDownOnLonelyBlockObject = defineBehavior({
-  on: 'keyboard.keydown',
-  guard: ({snapshot, event}) => {
-    const isArrowDown = defaultKeyboardShortcuts.arrowDown.guard(
-      event.originEvent,
-    )
-
-    if (!isArrowDown) {
-      return false
-    }
-
-    const collapsedSelection = isSelectionCollapsed(snapshot)
-
-    if (!collapsedSelection) {
-      return false
-    }
-
-    const focusBlockObject = getFocusBlockObject(snapshot)
-    const nextBlock = getNextBlock(snapshot)
-
-    return focusBlockObject && !nextBlock
-  },
-  actions: [
-    ({snapshot}) => [
-      raise({
-        type: 'insert.block',
-        block: {
-          _type: snapshot.context.schema.block.name,
-        },
-        placement: 'after',
-      }),
-    ],
-  ],
-})
-
-const arrowUpOnLonelyBlockObject = defineBehavior({
-  on: 'keyboard.keydown',
-  guard: ({snapshot, event}) => {
-    const isArrowUp = defaultKeyboardShortcuts.arrowUp.guard(event.originEvent)
-
-    if (!isArrowUp) {
-      return false
-    }
-
-    const collapsedSelection = isSelectionCollapsed(snapshot)
-
-    if (!collapsedSelection) {
-      return false
-    }
-
-    const focusBlockObject = getFocusBlockObject(snapshot)
-    const previousBlock = getPreviousBlock(snapshot)
-
-    return focusBlockObject && !previousBlock
-  },
-  actions: [
-    ({snapshot}) => [
-      raise({
-        type: 'insert.block',
-        block: {
-          _type: snapshot.context.schema.block.name,
-        },
-        placement: 'before',
-      }),
-    ],
-  ],
-})
-
-const breakingBlockObject = defineBehavior({
-  on: 'insert.break',
-  guard: ({snapshot}) => {
-    const focusBlockObject = getFocusBlockObject(snapshot)
-    const collapsedSelection = isSelectionCollapsed(snapshot)
-
-    return collapsedSelection && focusBlockObject !== undefined
-  },
-  actions: [
-    ({snapshot}) => [
-      raise({
-        type: 'insert.block',
-        block: {
-          _type: snapshot.context.schema.block.name,
-        },
-        placement: 'after',
-      }),
-    ],
-  ],
-})
-
-const clickingAboveLonelyBlockObject = defineBehavior({
-  on: 'mouse.click',
-  guard: ({snapshot, event}) => {
-    if (snapshot.context.readOnly) {
-      return false
-    }
-
-    if (snapshot.context.selection && !isSelectionCollapsed(snapshot)) {
-      return false
-    }
-
-    const focusBlockObject = getFocusBlockObject({
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-        selection: event.position.selection,
-      },
-    })
-    const previousBlock = getPreviousBlock({
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-        selection: event.position.selection,
-      },
-    })
-
-    return (
-      event.position.isEditor &&
-      event.position.block === 'start' &&
-      focusBlockObject &&
-      !previousBlock
-    )
-  },
-  actions: [
-    ({snapshot, event}) => [
-      raise({
-        type: 'select',
-        at: event.position.selection,
-      }),
-      raise({
-        type: 'insert.block',
-        block: {
-          _type: snapshot.context.schema.block.name,
-        },
-        placement: 'before',
-        select: 'start',
-      }),
-    ],
-  ],
-})
-
-const clickingBelowLonelyBlockObject = defineBehavior({
-  on: 'mouse.click',
-  guard: ({snapshot, event}) => {
-    if (snapshot.context.readOnly) {
-      return false
-    }
-
-    if (snapshot.context.selection && !isSelectionCollapsed(snapshot)) {
-      return false
-    }
-
-    const focusBlockObject = getFocusBlockObject({
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-        selection: event.position.selection,
-      },
-    })
-    const nextBlock = getNextBlock({
-      ...snapshot,
-      context: {
-        ...snapshot.context,
-        selection: event.position.selection,
-      },
-    })
-
-    return (
-      event.position.isEditor &&
-      event.position.block === 'end' &&
-      focusBlockObject &&
-      !nextBlock
-    )
-  },
-  actions: [
-    ({snapshot, event}) => [
-      raise({
-        type: 'select',
-        at: event.position.selection,
-      }),
-      raise({
-        type: 'insert.block',
-        block: {
-          _type: snapshot.context.schema.block.name,
-        },
-        placement: 'after',
-        select: 'start',
-      }),
-    ],
-  ],
-})
-
-const deletingEmptyTextBlockAfterBlockObject = defineBehavior({
-  on: 'delete.backward',
-  guard: ({snapshot}) => {
-    const focusTextBlock = getFocusTextBlock(snapshot)
-    const selectionCollapsed = isSelectionCollapsed(snapshot)
-    const previousBlock = getPreviousBlock(snapshot)
-
-    if (!focusTextBlock || !selectionCollapsed || !previousBlock) {
-      return false
-    }
-
-    if (
-      isEmptyTextBlock(snapshot.context, focusTextBlock.node) &&
-      !isTextBlock(snapshot.context, previousBlock.node)
-    ) {
-      return {focusTextBlock, previousBlock}
-    }
-
-    return false
-  },
-  actions: [
-    (_, {focusTextBlock, previousBlock}) => [
-      raise({
-        type: 'delete.block',
-        at: focusTextBlock.path,
-      }),
-      raise({
-        type: 'select',
-        at: {
-          anchor: {path: previousBlock.path, offset: 0},
-          focus: {path: previousBlock.path, offset: 0},
-        },
-      }),
-    ],
-  ],
-})
-
-const deletingEmptyTextBlockBeforeBlockObject = defineBehavior({
-  on: 'delete.forward',
-  guard: ({snapshot}) => {
-    const focusTextBlock = getFocusTextBlock(snapshot)
-    const selectionCollapsed = isSelectionCollapsed(snapshot)
-    const nextBlock = getNextBlock(snapshot)
-
-    if (!focusTextBlock || !selectionCollapsed || !nextBlock) {
-      return false
-    }
-
-    if (
-      isEmptyTextBlock(snapshot.context, focusTextBlock.node) &&
-      !isTextBlock(snapshot.context, nextBlock.node)
-    ) {
-      return {focusTextBlock, nextBlock}
-    }
-
-    return false
-  },
-  actions: [
-    (_, {focusTextBlock, nextBlock}) => [
-      raise({
-        type: 'delete.block',
-        at: focusTextBlock.path,
-      }),
-      raise({
-        type: 'select',
-        at: {
-          anchor: {path: nextBlock.path, offset: 0},
-          focus: {path: nextBlock.path, offset: 0},
-        },
-      }),
-    ],
-  ],
-})
-
-export const coreBlockObjectBehaviors = {
-  arrowDownOnLonelyBlockObject,
-  arrowUpOnLonelyBlockObject,
-  breakingBlockObject,
-  clickingAboveLonelyBlockObject,
-  clickingBelowLonelyBlockObject,
-  deletingEmptyTextBlockAfterBlockObject,
-  deletingEmptyTextBlockBeforeBlockObject,
-}

package/src/behaviors/behavior.core.decorators.ts

@@ -1,44 +0,0 @@
-import {defaultKeyboardShortcuts} from '../keyboard-shortcuts/default-keyboard-shortcuts'
-import {raise} from './behavior.types.action'
-import {defineBehavior} from './behavior.types.behavior'
-
-export const coreDecoratorBehaviors = {
-  strongShortcut: defineBehavior({
-    on: 'keyboard.keydown',
-    guard: ({snapshot, event}) =>
-      defaultKeyboardShortcuts.decorators.strong.guard(event.originEvent) &&
-      snapshot.context.schema.decorators.some(
-        (decorator) => decorator.name === 'strong',
-      ),
-    actions: [() => [raise({type: 'decorator.toggle', decorator: 'strong'})]],
-  }),
-  emShortcut: defineBehavior({
-    on: 'keyboard.keydown',
-    guard: ({snapshot, event}) =>
-      defaultKeyboardShortcuts.decorators.em.guard(event.originEvent) &&
-      snapshot.context.schema.decorators.some(
-        (decorator) => decorator.name === 'em',
-      ),
-    actions: [() => [raise({type: 'decorator.toggle', decorator: 'em'})]],
-  }),
-  underlineShortcut: defineBehavior({
-    on: 'keyboard.keydown',
-    guard: ({snapshot, event}) =>
-      defaultKeyboardShortcuts.decorators.underline.guard(event.originEvent) &&
-      snapshot.context.schema.decorators.some(
-        (decorator) => decorator.name === 'underline',
-      ),
-    actions: [
-      () => [raise({type: 'decorator.toggle', decorator: 'underline'})],
-    ],
-  }),
-  codeShortcut: defineBehavior({
-    on: 'keyboard.keydown',
-    guard: ({snapshot, event}) =>
-      defaultKeyboardShortcuts.decorators.code.guard(event.originEvent) &&
-      snapshot.context.schema.decorators.some(
-        (decorator) => decorator.name === 'code',
-      ),
-    actions: [() => [raise({type: 'decorator.toggle', decorator: 'code'})]],
-  }),
-}