@portabletext/editor 3.3.2 → 3.3.4

package/src/behaviors/behavior.abstract.list-item.ts

@@ -1,70 +0,0 @@
-import {getSelectedTextBlocks} from '../selectors/selector.get-selected-text-blocks'
-import {isActiveListItem} from '../selectors/selector.is-active-list-item'
-import {raise} from './behavior.types.action'
-import {defineBehavior} from './behavior.types.behavior'
-
-export const abstractListItemBehaviors = [
-  defineBehavior({
-    on: 'list item.add',
-    guard: ({snapshot, event}) => {
-      if (
-        !snapshot.context.schema.lists.some(
-          (list) => list.name === event.listItem,
-        )
-      ) {
-        return false
-      }
-
-      const selectedTextBlocks = getSelectedTextBlocks(snapshot)
-
-      return {selectedTextBlocks}
-    },
-    actions: [
-      ({event}, {selectedTextBlocks}) =>
-        selectedTextBlocks.map((block) =>
-          raise({
-            type: 'block.set',
-            at: block.path,
-            props: {
-              level: block.node.level ?? 1,
-              listItem: event.listItem,
-            },
-          }),
-        ),
-    ],
-  }),
-  defineBehavior({
-    on: 'list item.remove',
-    guard: ({snapshot}) => {
-      const selectedTextBlocks = getSelectedTextBlocks(snapshot)
-
-      return {selectedTextBlocks}
-    },
-    actions: [
-      (_, {selectedTextBlocks}) =>
-        selectedTextBlocks.map((block) =>
-          raise({
-            type: 'block.unset',
-            at: block.path,
-            props: ['level', 'listItem'],
-          }),
-        ),
-    ],
-  }),
-  defineBehavior({
-    on: 'list item.toggle',
-    guard: ({snapshot, event}) => isActiveListItem(event.listItem)(snapshot),
-    actions: [
-      ({event}) => [
-        raise({type: 'list item.remove', listItem: event.listItem}),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'list item.toggle',
-    guard: ({snapshot, event}) => !isActiveListItem(event.listItem)(snapshot),
-    actions: [
-      ({event}) => [raise({type: 'list item.add', listItem: event.listItem})],
-    ],
-  }),
-]

package/src/behaviors/behavior.abstract.move.ts

@@ -1,79 +0,0 @@
-import {getNextBlock} from '../selectors/selector.get-next-block'
-import {getPreviousBlock} from '../selectors/selector.get-previous-block'
-import {raise} from './behavior.types.action'
-import {defineBehavior} from './behavior.types.behavior'
-
-export const abstractMoveBehaviors = [
-  defineBehavior({
-    on: 'move.block up',
-    guard: ({snapshot, event}) => {
-      const previousBlock = getPreviousBlock({
-        ...snapshot,
-        context: {
-          ...snapshot.context,
-          selection: {
-            anchor: {
-              path: event.at,
-              offset: 0,
-            },
-            focus: {
-              path: event.at,
-              offset: 0,
-            },
-          },
-        },
-      })
-
-      if (previousBlock) {
-        return {previousBlock}
-      }
-
-      return false
-    },
-    actions: [
-      ({event}, {previousBlock}) => [
-        raise({
-          type: 'move.block',
-          at: event.at,
-          to: previousBlock.path,
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'move.block down',
-    guard: ({snapshot, event}) => {
-      const nextBlock = getNextBlock({
-        ...snapshot,
-        context: {
-          ...snapshot.context,
-          selection: {
-            anchor: {
-              path: event.at,
-              offset: 0,
-            },
-            focus: {
-              path: event.at,
-              offset: 0,
-            },
-          },
-        },
-      })
-
-      if (nextBlock) {
-        return {nextBlock}
-      }
-
-      return false
-    },
-    actions: [
-      ({event}, {nextBlock}) => [
-        raise({
-          type: 'move.block',
-          at: event.at,
-          to: nextBlock.path,
-        }),
-      ],
-    ],
-  }),
-]

package/src/behaviors/behavior.abstract.select.ts

@@ -1,118 +0,0 @@
-import {getFocusBlock} from '../selectors/selector.get-focus-block'
-import {getNextBlock} from '../selectors/selector.get-next-block'
-import {getPreviousBlock} from '../selectors/selector.get-previous-block'
-import {getBlockEndPoint} from '../utils/util.get-block-end-point'
-import {raise} from './behavior.types.action'
-import {defineBehavior} from './behavior.types.behavior'
-
-export const abstractSelectBehaviors = [
-  defineBehavior({
-    on: 'select.block',
-    guard: ({snapshot, event}) => {
-      if (event.select !== 'end') {
-        return false
-      }
-
-      const block = getFocusBlock({
-        ...snapshot,
-        context: {
-          ...snapshot.context,
-          selection: {
-            anchor: {
-              path: event.at,
-              offset: 0,
-            },
-            focus: {
-              path: event.at,
-              offset: 0,
-            },
-          },
-        },
-      })
-
-      if (!block) {
-        return false
-      }
-
-      const blockEndPoint = getBlockEndPoint({
-        context: snapshot.context,
-        block,
-      })
-
-      return {blockEndPoint}
-    },
-    actions: [
-      (_, {blockEndPoint}) => [
-        raise({
-          type: 'select',
-          at: {
-            anchor: blockEndPoint,
-            focus: blockEndPoint,
-          },
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'select.block',
-    actions: [
-      ({event}) => [
-        raise({
-          type: 'select',
-          at: {
-            anchor: {
-              path: event.at,
-              offset: 0,
-            },
-            focus: {
-              path: event.at,
-              offset: 0,
-            },
-          },
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'select.previous block',
-    guard: ({snapshot}) => {
-      const previousBlock = getPreviousBlock(snapshot)
-
-      if (!previousBlock) {
-        return false
-      }
-
-      return {previousBlock}
-    },
-    actions: [
-      ({event}, {previousBlock}) => [
-        raise({
-          type: 'select.block',
-          at: previousBlock.path,
-          select: event.select,
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'select.next block',
-    guard: ({snapshot}) => {
-      const nextBlock = getNextBlock(snapshot)
-
-      if (!nextBlock) {
-        return false
-      }
-
-      return {nextBlock}
-    },
-    actions: [
-      ({event}, {nextBlock}) => [
-        raise({
-          type: 'select.block',
-          at: nextBlock.path,
-          select: event.select,
-        }),
-      ],
-    ],
-  }),
-]

package/src/behaviors/behavior.abstract.serialize.ts

@@ -1,96 +0,0 @@
-import {raise} from './behavior.types.action'
-import {defineBehavior} from './behavior.types.behavior'
-
-export const abstractSerializeBehaviors = [
-  defineBehavior({
-    on: 'serialize',
-    actions: [
-      ({event}) => [
-        raise({
-          type: 'serialize.data',
-          mimeType: 'application/x-portable-text',
-          originEvent: event.originEvent,
-        }),
-        raise({
-          type: 'serialize.data',
-          mimeType: 'application/json',
-          originEvent: event.originEvent,
-        }),
-        raise({
-          type: 'serialize.data',
-          mimeType: 'text/markdown',
-          originEvent: event.originEvent,
-        }),
-        raise({
-          type: 'serialize.data',
-          mimeType: 'text/html',
-          originEvent: event.originEvent,
-        }),
-        raise({
-          type: 'serialize.data',
-          mimeType: 'text/plain',
-          originEvent: event.originEvent,
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'serialize.data',
-    guard: ({snapshot, event}) => {
-      const converter = snapshot.context.converters.find(
-        (converter) => converter.mimeType === event.mimeType,
-      )
-
-      if (!converter) {
-        return false
-      }
-
-      return converter.serialize({
-        snapshot,
-        event: {
-          type: 'serialize',
-          originEvent: event.originEvent.type,
-        },
-      })
-    },
-    actions: [
-      ({event}, serializeEvent) => [
-        raise({
-          ...serializeEvent,
-          originEvent: event.originEvent,
-        }),
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'serialization.success',
-    actions: [
-      ({event}) => [
-        {
-          type: 'effect',
-          effect: () => {
-            event.originEvent.originEvent.dataTransfer.setData(
-              event.mimeType,
-              event.data,
-            )
-          },
-        },
-      ],
-    ],
-  }),
-  defineBehavior({
-    on: 'serialization.failure',
-    actions: [
-      ({event}) => [
-        {
-          type: 'effect',
-          effect: () => {
-            console.warn(
-              `Serialization of ${event.mimeType} failed with reason "${event.reason}"`,
-            )
-          },
-        },
-      ],
-    ],
-  }),
-]

package/src/behaviors/behavior.abstract.split.ts

@@ -1,170 +0,0 @@
-import {isTextBlock} from '@portabletext/schema'
-import {isSelectionExpanded} from '../selectors'
-import {getFocusBlockObject} from '../selectors/selector.get-focus-block-object'
-import {getFocusInlineObject} from '../selectors/selector.get-focus-inline-object'
-import {getFocusTextBlock} from '../selectors/selector.get-focus-text-block'
-import {getSelectionEndBlock} from '../selectors/selector.get-selection-end-block'
-import {getSelectionStartBlock} from '../selectors/selector.get-selection-start-block'
-import {isEqualSelectionPoints} from '../utils'
-import {parseBlock} from '../utils/parse-blocks'
-import {getBlockEndPoint} from '../utils/util.get-block-end-point'
-import {getBlockStartPoint} from '../utils/util.get-block-start-point'
-import {getSelectionEndPoint} from '../utils/util.get-selection-end-point'
-import {getSelectionStartPoint} from '../utils/util.get-selection-start-point'
-import {isSelectionCollapsed} from '../utils/util.is-selection-collapsed'
-import {sliceTextBlock} from '../utils/util.slice-text-block'
-import {raise} from './behavior.types.action'
-import {defineBehavior} from './behavior.types.behavior'
-
-export const abstractSplitBehaviors = [
-  /**
-   * You can't split an inline object.
-   */
-  defineBehavior({
-    on: 'split',
-    guard: ({snapshot}) =>
-      isSelectionCollapsed(snapshot.context.selection) &&
-      getFocusInlineObject(snapshot),
-    actions: [],
-  }),
-
-  /**
-   * You can't split a block object.
-   */
-  defineBehavior({
-    on: 'split',
-    guard: ({snapshot}) =>
-      isSelectionCollapsed(snapshot.context.selection) &&
-      getFocusBlockObject(snapshot),
-    actions: [],
-  }),
-
-  defineBehavior({
-    on: 'split',
-    guard: ({snapshot}) => {
-      const selection = snapshot.context.selection
-
-      if (!selection || isSelectionCollapsed(selection)) {
-        return false
-      }
-
-      const startPoint = getSelectionStartPoint(selection)
-      const endPoint = getSelectionEndPoint(selection)
-
-      if (!startPoint || !endPoint) {
-        return false
-      }
-
-      const startBlock = getSelectionStartBlock(snapshot)
-      const endBlock = getSelectionEndBlock(snapshot)
-
-      if (!startBlock || !endBlock) {
-        return false
-      }
-
-      const startBlockStartPoint = getBlockStartPoint({
-        context: snapshot.context,
-        block: startBlock,
-      })
-      const endBlockEndPoint = getBlockEndPoint({
-        context: snapshot.context,
-        block: endBlock,
-      })
-
-      if (
-        isTextBlock(snapshot.context, startBlock.node) &&
-        isTextBlock(snapshot.context, endBlock.node) &&
-        !isEqualSelectionPoints(startPoint, startBlockStartPoint) &&
-        !isEqualSelectionPoints(endPoint, endBlockEndPoint)
-      ) {
-        return true
-      }
-
-      return false
-    },
-    actions: [() => [raise({type: 'delete'}), raise({type: 'split'})]],
-  }),
-
-  defineBehavior({
-    on: 'split',
-    guard: ({snapshot}) => {
-      return isSelectionExpanded(snapshot)
-    },
-    actions: [() => [raise({type: 'delete'})]],
-  }),
-
-  defineBehavior({
-    on: 'split',
-    guard: ({snapshot}) => {
-      const selection = snapshot.context.selection
-
-      if (!selection || !isSelectionCollapsed(selection)) {
-        return false
-      }
-
-      const selectionStartPoint = getSelectionStartPoint(selection)
-
-      const focusTextBlock = getFocusTextBlock(snapshot)
-
-      if (!focusTextBlock) {
-        return false
-      }
-
-      const blockEndPoint = getBlockEndPoint({
-        context: snapshot.context,
-        block: focusTextBlock,
-      })
-
-      const newTextBlockSelection = {
-        anchor: selectionStartPoint,
-        focus: blockEndPoint,
-      }
-
-      const newTextBlock = parseBlock({
-        block: sliceTextBlock({
-          context: {
-            ...snapshot.context,
-            selection: newTextBlockSelection,
-          },
-          block: focusTextBlock.node,
-        }),
-        context: snapshot.context,
-        options: {
-          normalize: false,
-          removeUnusedMarkDefs: true,
-          validateFields: false,
-        },
-      })
-
-      if (!newTextBlock) {
-        return false
-      }
-
-      return {
-        newTextBlock,
-        newTextBlockSelection,
-      }
-    },
-    actions: [
-      (_, {newTextBlock, newTextBlockSelection}) =>
-        isSelectionCollapsed(newTextBlockSelection)
-          ? [
-              raise({
-                type: 'insert.block',
-                block: newTextBlock,
-                placement: 'after',
-                select: 'start',
-              }),
-            ]
-          : [
-              raise({type: 'delete', at: newTextBlockSelection}),
-              raise({
-                type: 'insert.block',
-                block: newTextBlock,
-                placement: 'after',
-                select: 'start',
-              }),
-            ],
-    ],
-  }),
-]

package/src/behaviors/behavior.abstract.style.ts

@@ -1,55 +0,0 @@
-import {getSelectedTextBlocks} from '../selectors/selector.get-selected-text-blocks'
-import {isActiveStyle} from '../selectors/selector.is-active-style'
-import {raise} from './behavior.types.action'
-import {defineBehavior} from './behavior.types.behavior'
-
-export const abstractStyleBehaviors = [
-  defineBehavior({
-    on: 'style.add',
-    guard: ({snapshot}) => {
-      const selectedTextBlocks = getSelectedTextBlocks(snapshot)
-
-      return {selectedTextBlocks}
-    },
-    actions: [
-      ({event}, {selectedTextBlocks}) =>
-        selectedTextBlocks.map((block) =>
-          raise({
-            type: 'block.set',
-            at: block.path,
-            props: {
-              style: event.style,
-            },
-          }),
-        ),
-    ],
-  }),
-  defineBehavior({
-    on: 'style.remove',
-    guard: ({snapshot}) => {
-      const selectedTextBlocks = getSelectedTextBlocks(snapshot)
-
-      return {selectedTextBlocks}
-    },
-    actions: [
-      (_, {selectedTextBlocks}) =>
-        selectedTextBlocks.map((block) =>
-          raise({
-            type: 'block.unset',
-            at: block.path,
-            props: ['style'],
-          }),
-        ),
-    ],
-  }),
-  defineBehavior({
-    on: 'style.toggle',
-    guard: ({snapshot, event}) => isActiveStyle(event.style)(snapshot),
-    actions: [({event}) => [raise({type: 'style.remove', style: event.style})]],
-  }),
-  defineBehavior({
-    on: 'style.toggle',
-    guard: ({snapshot, event}) => !isActiveStyle(event.style)(snapshot),
-    actions: [({event}) => [raise({type: 'style.add', style: event.style})]],
-  }),
-]