@portabletext/editor 3.3.2 → 3.3.4

package/src/behaviors/behavior.core.ts

@@ -1,44 +0,0 @@
-import {corePriority} from '../priority/priority.core'
-import {coreAnnotationBehaviors} from './behavior.core.annotations'
-import {coreBlockObjectBehaviors} from './behavior.core.block-objects'
-import {coreDecoratorBehaviors} from './behavior.core.decorators'
-import {coreDndBehaviors} from './behavior.core.dnd'
-import {coreInsertBehaviors} from './behavior.core.insert'
-import {coreInsertBreakBehaviors} from './behavior.core.insert-break'
-import {coreListBehaviors} from './behavior.core.lists'
-
-export const coreBehaviorsConfig = [
-  ...coreAnnotationBehaviors,
-  coreDecoratorBehaviors.strongShortcut,
-  coreDecoratorBehaviors.emShortcut,
-  coreDecoratorBehaviors.underlineShortcut,
-  coreDecoratorBehaviors.codeShortcut,
-  ...coreDndBehaviors,
-  coreBlockObjectBehaviors.clickingAboveLonelyBlockObject,
-  coreBlockObjectBehaviors.clickingBelowLonelyBlockObject,
-  coreBlockObjectBehaviors.arrowDownOnLonelyBlockObject,
-  coreBlockObjectBehaviors.arrowUpOnLonelyBlockObject,
-  coreBlockObjectBehaviors.breakingBlockObject,
-  coreBlockObjectBehaviors.deletingEmptyTextBlockAfterBlockObject,
-  coreBlockObjectBehaviors.deletingEmptyTextBlockBeforeBlockObject,
-  ...coreInsertBehaviors,
-  coreListBehaviors.clearListOnBackspace,
-  coreListBehaviors.unindentListOnBackspace,
-  coreListBehaviors.mergeTextIntoListOnDelete,
-  coreListBehaviors.mergeTextIntoListOnBackspace,
-  coreListBehaviors.deletingListFromStart,
-  coreListBehaviors.clearListOnEnter,
-  coreListBehaviors.indentListOnTab,
-  coreListBehaviors.unindentListOnShiftTab,
-  coreListBehaviors.inheritListLevel,
-  coreListBehaviors.inheritListItem,
-  coreListBehaviors.inheritListProperties,
-  coreInsertBreakBehaviors.breakingAtTheEndOfTextBlock,
-  coreInsertBreakBehaviors.breakingAtTheStartOfTextBlock,
-  coreInsertBreakBehaviors.breakingEntireDocument,
-  coreInsertBreakBehaviors.breakingEntireBlocks,
-  coreInsertBreakBehaviors.breakingInlineObject,
-].map((behavior) => ({
-  behavior,
-  priority: corePriority,
-}))

package/src/behaviors/behavior.perform-event.ts

@@ -1,354 +0,0 @@
-import {createEditorDom} from '../editor/editor-dom'
-import type {EditorSchema} from '../editor/editor-schema'
-import type {EditorSnapshot} from '../editor/editor-snapshot'
-import {withPerformingBehaviorOperation} from '../editor/with-performing-behavior-operation'
-import {withoutNormalizingConditional} from '../editor/without-normalizing-conditional'
-import {clearUndoStepId, createUndoStepId} from '../history/undo-step'
-import {debugWithName} from '../internal-utils/debug'
-import {performOperation} from '../operations/behavior.operations'
-import type {PortableTextSlateEditor} from '../types/slate-editor'
-import {abstractBehaviors} from './behavior.abstract'
-import type {BehaviorAction} from './behavior.types.action'
-import type {Behavior} from './behavior.types.behavior'
-import {
-  isAbstractBehaviorEvent,
-  isCustomBehaviorEvent,
-  isNativeBehaviorEvent,
-  isSyntheticBehaviorEvent,
-  type BehaviorEvent,
-  type ExternalBehaviorEvent,
-} from './behavior.types.event'
-
-const debug = debugWithName('behaviors:event')
-
-function eventCategory(event: BehaviorEvent) {
-  return isNativeBehaviorEvent(event)
-    ? 'native'
-    : isAbstractBehaviorEvent(event)
-      ? 'synthetic'
-      : isCustomBehaviorEvent(event)
-        ? 'custom'
-        : 'synthetic'
-}
-
-export function performEvent({
-  mode,
-  behaviors,
-  remainingEventBehaviors,
-  event,
-  editor,
-  keyGenerator,
-  schema,
-  getSnapshot,
-  nativeEvent,
-  sendBack,
-}: {
-  mode: 'send' | 'raise' | 'execute' | 'forward'
-  behaviors: Array<Behavior>
-  remainingEventBehaviors: Array<Behavior>
-  event: BehaviorEvent
-  editor: PortableTextSlateEditor
-  keyGenerator: () => string
-  schema: EditorSchema
-  getSnapshot: () => EditorSnapshot
-  nativeEvent:
-    | {
-        preventDefault: () => void
-      }
-    | undefined
-  sendBack: (
-    event: {type: 'set drag ghost'; ghost: HTMLElement} | ExternalBehaviorEvent,
-  ) => void
-}) {
-  if (mode === 'send' && !isNativeBehaviorEvent(event)) {
-    createUndoStepId(editor)
-  }
-
-  debug(`(${mode}:${eventCategory(event)})`, JSON.stringify(event, null, 2))
-
-  const eventBehaviors = [
-    ...remainingEventBehaviors,
-    ...abstractBehaviors,
-  ].filter((behavior) => {
-    // Catches all events
-    if (behavior.on === '*') {
-      return true
-    }
-
-    const [listenedNamespace] =
-      behavior.on.includes('*') && behavior.on.includes('.')
-        ? behavior.on.split('.')
-        : [undefined]
-    const [eventNamespace] = event.type.includes('.')
-      ? event.type.split('.')
-      : [undefined]
-
-    // Handles scenarios like a Behavior listening for `select.*` and the event
-    // `select.block` is fired.
-    if (
-      listenedNamespace !== undefined &&
-      eventNamespace !== undefined &&
-      listenedNamespace === eventNamespace
-    ) {
-      return true
-    }
-
-    // Handles scenarios like a Behavior listening for `select.*` and the event
-    // `select` is fired.
-    if (
-      listenedNamespace !== undefined &&
-      eventNamespace === undefined &&
-      listenedNamespace === event.type
-    ) {
-      return true
-    }
-
-    return behavior.on === event.type
-  })
-
-  if (eventBehaviors.length === 0 && isSyntheticBehaviorEvent(event)) {
-    nativeEvent?.preventDefault()
-
-    if (mode === 'send') {
-      clearUndoStepId(editor)
-    }
-
-    withPerformingBehaviorOperation(editor, () => {
-      debug(`(execute:${eventCategory(event)})`, JSON.stringify(event, null, 2))
-
-      performOperation({
-        context: {
-          keyGenerator,
-          schema,
-        },
-        operation: {
-          ...event,
-          editor,
-        },
-      })
-    })
-
-    editor.onChange()
-
-    return
-  }
-
-  const guardSnapshot = getSnapshot()
-
-  let nativeEventPrevented = false
-  let defaultBehaviorOverwritten = false
-  let eventBehaviorIndex = -1
-
-  for (const eventBehavior of eventBehaviors) {
-    eventBehaviorIndex++
-
-    let shouldRun = false
-
-    try {
-      shouldRun =
-        eventBehavior.guard === undefined ||
-        eventBehavior.guard({
-          snapshot: guardSnapshot,
-          event,
-          dom: createEditorDom(sendBack, editor),
-        })
-    } catch (error) {
-      console.error(
-        new Error(
-          `Evaluating guard for "${event.type}" failed due to: ${error.message}`,
-        ),
-      )
-    }
-
-    if (!shouldRun) {
-      continue
-    }
-
-    // This Behavior now "owns" the event and we can consider the default
-    // action prevented
-    defaultBehaviorOverwritten = true
-
-    if (eventBehavior.actions.length === 0) {
-      nativeEventPrevented = true
-    }
-
-    let actionSetIndex = -1
-
-    for (const actionSet of eventBehavior.actions) {
-      actionSetIndex++
-
-      const actionsSnapshot = getSnapshot()
-
-      let actions: Array<BehaviorAction> = []
-
-      try {
-        actions = actionSet(
-          {
-            snapshot: actionsSnapshot,
-            event,
-            dom: createEditorDom(sendBack, editor),
-          },
-          shouldRun,
-        )
-      } catch (error) {
-        console.error(
-          new Error(
-            `Evaluating actions for "${event.type}" failed due to: ${error.message}`,
-          ),
-        )
-      }
-
-      if (actions.length === 0) {
-        continue
-      }
-
-      nativeEventPrevented =
-        actions.some(
-          (action) => action.type === 'raise' || action.type === 'execute',
-        ) || !actions.some((action) => action.type === 'forward')
-
-      let undoStepCreated = false
-
-      if (actionSetIndex > 0) {
-        // Since there are multiple action sets
-        createUndoStepId(editor)
-
-        undoStepCreated = true
-      }
-
-      if (
-        !undoStepCreated &&
-        actions.some((action) => action.type === 'execute')
-      ) {
-        // Since at least one action is about to `execute` changes in the editor,
-        // we set up a new undo step.
-        // All actions performed recursively from now will be squashed into this
-        // undo step
-        createUndoStepId(editor)
-
-        undoStepCreated = true
-      }
-
-      const actionTypes = actions.map((action) => action.type)
-      const uniqueActionTypes = new Set(actionTypes)
-
-      // The set of actions are all `raise` actions
-      const raiseGroup =
-        actionTypes.length > 1 &&
-        uniqueActionTypes.size === 1 &&
-        uniqueActionTypes.has('raise')
-
-      // The set of actions are all `execute` actions
-      const executeGroup =
-        actionTypes.length > 1 &&
-        uniqueActionTypes.size === 1 &&
-        uniqueActionTypes.has('execute')
-
-      withoutNormalizingConditional(
-        editor,
-        () => raiseGroup || executeGroup,
-        () => {
-          for (const action of actions) {
-            if (action.type === 'effect') {
-              try {
-                action.effect({
-                  send: sendBack,
-                })
-              } catch (error) {
-                console.error(
-                  new Error(
-                    `Executing effect as a result of "${event.type}" failed due to: ${error.message}`,
-                  ),
-                )
-              }
-
-              continue
-            }
-
-            if (action.type === 'forward') {
-              const remainingEventBehaviors = eventBehaviors.slice(
-                eventBehaviorIndex + 1,
-              )
-
-              performEvent({
-                mode: mode === 'execute' ? 'execute' : 'forward',
-                behaviors,
-                remainingEventBehaviors: remainingEventBehaviors,
-                event: action.event,
-                editor,
-                keyGenerator,
-                schema,
-                getSnapshot,
-                nativeEvent,
-                sendBack,
-              })
-
-              continue
-            }
-
-            if (action.type === 'raise') {
-              performEvent({
-                mode: mode === 'execute' ? 'execute' : 'raise',
-                behaviors,
-                remainingEventBehaviors:
-                  mode === 'execute' ? remainingEventBehaviors : behaviors,
-                event: action.event,
-                editor,
-                keyGenerator,
-                schema,
-                getSnapshot,
-                nativeEvent,
-                sendBack,
-              })
-
-              continue
-            }
-
-            performEvent({
-              mode: 'execute',
-              behaviors,
-              remainingEventBehaviors: [],
-              event: action.event,
-              editor,
-              keyGenerator,
-              schema,
-              getSnapshot,
-              nativeEvent: undefined,
-              sendBack,
-            })
-          }
-        },
-      )
-
-      if (undoStepCreated) {
-        clearUndoStepId(editor)
-      }
-    }
-
-    break
-  }
-
-  if (!defaultBehaviorOverwritten && isSyntheticBehaviorEvent(event)) {
-    nativeEvent?.preventDefault()
-
-    if (mode === 'send') {
-      clearUndoStepId(editor)
-    }
-
-    withPerformingBehaviorOperation(editor, () => {
-      debug(`(execute:${eventCategory(event)})`, JSON.stringify(event, null, 2))
-
-      performOperation({
-        context: {keyGenerator, schema},
-        operation: {
-          ...event,
-          editor,
-        },
-      })
-    })
-
-    editor.onChange()
-  } else if (nativeEventPrevented) {
-    nativeEvent?.preventDefault()
-  }
-}

package/src/behaviors/behavior.types.action.ts

@@ -1,102 +0,0 @@
-import type {EditorDom} from '../editor/editor-dom'
-import type {EditorSnapshot} from '../editor/editor-snapshot'
-import type {PickFromUnion} from '../type-utils'
-import type {
-  CustomBehaviorEvent,
-  ExternalBehaviorEvent,
-  NativeBehaviorEvent,
-  SyntheticBehaviorEvent,
-} from './behavior.types.event'
-
-/**
- * @beta
- */
-export type BehaviorAction =
-  | {
-      type: 'execute'
-      event: SyntheticBehaviorEvent
-    }
-  | {
-      type: 'forward'
-      event: NativeBehaviorEvent | SyntheticBehaviorEvent | CustomBehaviorEvent
-    }
-  | {
-      type: 'raise'
-      event: SyntheticBehaviorEvent | CustomBehaviorEvent
-    }
-  | {
-      type: 'effect'
-      effect: (payload: {
-        /**
-         * Send a Behavior Event back into the Editor.
-         *
-         * @example
-         * ```ts
-         * defineBehavior({
-         *   on: '...',
-         *   actions: [
-         *     () => [
-         *       effect(({send}) => {
-         *         doSomethingAsync()
-         *           .then(() => {
-         *             send({
-         *               type: '...',
-         *             })
-         *           })
-         *       })
-         *     ],
-         *   ],
-         * })
-         * ```
-         */
-        send: (event: ExternalBehaviorEvent) => void
-      }) => void
-    }
-
-/**
- * @beta
- */
-export function execute(
-  event: SyntheticBehaviorEvent,
-): PickFromUnion<BehaviorAction, 'type', 'execute'> {
-  return {type: 'execute', event}
-}
-
-/**
- * @beta
- */
-export function forward(
-  event: NativeBehaviorEvent | SyntheticBehaviorEvent | CustomBehaviorEvent,
-): PickFromUnion<BehaviorAction, 'type', 'forward'> {
-  return {type: 'forward', event}
-}
-
-/**
- * @beta
- */
-export function raise(
-  event: SyntheticBehaviorEvent | CustomBehaviorEvent,
-): PickFromUnion<BehaviorAction, 'type', 'raise'> {
-  return {type: 'raise', event}
-}
-
-/**
- * @beta
- */
-export function effect(
-  effect: PickFromUnion<BehaviorAction, 'type', 'effect'>['effect'],
-): PickFromUnion<BehaviorAction, 'type', 'effect'> {
-  return {type: 'effect', effect}
-}
-
-/**
- * @beta
- */
-export type BehaviorActionSet<TBehaviorEvent, TGuardResponse> = (
-  payload: {
-    snapshot: EditorSnapshot
-    event: TBehaviorEvent
-    dom: EditorDom
-  },
-  guardResponse: TGuardResponse,
-) => Array<BehaviorAction>

package/src/behaviors/behavior.types.behavior.ts

@@ -1,83 +0,0 @@
-import type {BehaviorActionSet} from './behavior.types.action'
-import type {
-  BehaviorEvent,
-  BehaviorEventTypeNamespace,
-  CustomBehaviorEvent,
-  ResolveBehaviorEvent,
-} from './behavior.types.event'
-import type {BehaviorGuard} from './behavior.types.guard'
-
-/**
- * @beta
- */
-export type Behavior<
-  TBehaviorEventType extends
-    | '*'
-    | `${BehaviorEventTypeNamespace}.*`
-    | BehaviorEvent['type'] =
-    | '*'
-    | `${BehaviorEventTypeNamespace}.*`
-    | BehaviorEvent['type'],
-  TGuardResponse = true,
-  TBehaviorEvent extends ResolveBehaviorEvent<TBehaviorEventType> =
-    ResolveBehaviorEvent<TBehaviorEventType>,
-> = {
-  /**
-   * Editor Event that triggers this Behavior.
-   */
-  on: TBehaviorEventType
-  /**
-   * Predicate function that determines if the Behavior should be executed.
-   * Returning a non-nullable value from the guard will pass the value to the
-   * actions and execute them.
-   */
-  guard?: BehaviorGuard<TBehaviorEvent, TGuardResponse>
-  /**
-   * Array of Behavior Action sets.
-   * Each set represents a step in the history stack.
-   */
-  actions: Array<BehaviorActionSet<TBehaviorEvent, TGuardResponse>>
-}
-
-/**
- * @beta
- *
- * @example
- *
- * ```tsx
- * const noLowerCaseA = defineBehavior({
- *   on: 'insert.text',
- *   guard: ({event, snapshot}) => event.text === 'a',
- *   actions: [({event, snapshot}) => [{type: 'insert.text', text: 'A'}]],
- * })
- * ```
- *
- */
-export function defineBehavior<
-  TPayload extends Record<string, unknown>,
-  TBehaviorEventType extends
-    | '*'
-    | `${BehaviorEventTypeNamespace}.*`
-    | BehaviorEvent['type'] = CustomBehaviorEvent['type'],
-  TGuardResponse = true,
->(
-  behavior: Behavior<
-    TBehaviorEventType,
-    TGuardResponse,
-    ResolveBehaviorEvent<TBehaviorEventType, TPayload>
-  >,
-): Behavior
-export function defineBehavior<
-  TPayload extends never = never,
-  TBehaviorEventType extends
-    | '*'
-    | `${BehaviorEventTypeNamespace}.*`
-    | BehaviorEvent['type'] = BehaviorEvent['type'],
-  TGuardResponse = true,
-  TBehaviorEvent extends ResolveBehaviorEvent<TBehaviorEventType, TPayload> =
-    ResolveBehaviorEvent<TBehaviorEventType, TPayload>,
->(
-  behavior: Behavior<TBehaviorEventType, TGuardResponse, TBehaviorEvent>,
-): Behavior {
-  return behavior as unknown as Behavior
-}