@portabletext/editor 3.0.8 → 3.1.0

package/src/behaviors/behavior.markdown.ts

@@ -1,478 +0,0 @@
-import {isTextBlock} from '@portabletext/schema'
-import type {EditorSchema} from '../editor/editor-schema'
-import {getFocusBlock} from '../selectors/selector.get-focus-block'
-import {getFocusSpan} from '../selectors/selector.get-focus-span'
-import {getFocusTextBlock} from '../selectors/selector.get-focus-text-block'
-import {getPreviousInlineObject} from '../selectors/selector.get-previous-inline-object'
-import {getBlockTextBefore} from '../selectors/selector.get-text-before'
-import {isSelectionCollapsed} from '../selectors/selector.is-selection-collapsed'
-import {spanSelectionPointToBlockOffset} from '../utils/util.block-offset'
-import {getTextBlockText} from '../utils/util.get-text-block-text'
-import {execute} from './behavior.types.action'
-import {defineBehavior} from './behavior.types.behavior'
-
-export type MarkdownBehaviorsConfig = {
-  horizontalRuleObject?: (context: {
-    schema: EditorSchema
-  }) => {name: string; value?: {[prop: string]: unknown}} | undefined
-  defaultStyle?: (context: {schema: EditorSchema}) => string | undefined
-  headingStyle?: (context: {
-    schema: EditorSchema
-    level: number
-  }) => string | undefined
-  blockquoteStyle?: (context: {schema: EditorSchema}) => string | undefined
-  unorderedListStyle?: (context: {schema: EditorSchema}) => string | undefined
-  orderedListStyle?: (context: {schema: EditorSchema}) => string | undefined
-}
-
-export function createMarkdownBehaviors(config: MarkdownBehaviorsConfig) {
-  const automaticBlockquoteOnSpace = defineBehavior({
-    on: 'insert.text',
-    guard: ({snapshot, event}) => {
-      const isSpace = event.text === ' '
-
-      if (!isSpace) {
-        return false
-      }
-
-      const selectionCollapsed = isSelectionCollapsed(snapshot)
-      const focusTextBlock = getFocusTextBlock(snapshot)
-      const focusSpan = getFocusSpan(snapshot)
-
-      if (!selectionCollapsed || !focusTextBlock || !focusSpan) {
-        return false
-      }
-
-      const previousInlineObject = getPreviousInlineObject(snapshot)
-      const blockOffset = spanSelectionPointToBlockOffset({
-        context: snapshot.context,
-        selectionPoint: {
-          path: [
-            {_key: focusTextBlock.node._key},
-            'children',
-            {_key: focusSpan.node._key},
-          ],
-          offset: snapshot.context.selection?.focus.offset ?? 0,
-        },
-      })
-
-      if (previousInlineObject || !blockOffset) {
-        return false
-      }
-
-      const blockText = getTextBlockText(focusTextBlock.node)
-      const caretAtTheEndOfQuote = blockOffset.offset === 1
-      const looksLikeMarkdownQuote = /^>/.test(blockText)
-      const blockquoteStyle = config.blockquoteStyle?.(snapshot.context)
-
-      if (
-        caretAtTheEndOfQuote &&
-        looksLikeMarkdownQuote &&
-        blockquoteStyle !== undefined
-      ) {
-        return {focusTextBlock, style: blockquoteStyle}
-      }
-
-      return false
-    },
-    actions: [
-      () => [
-        execute({
-          type: 'insert.text',
-          text: ' ',
-        }),
-      ],
-      (_, {focusTextBlock, style}) => [
-        execute({
-          type: 'block.unset',
-          props: ['listItem', 'level'],
-          at: focusTextBlock.path,
-        }),
-        execute({
-          type: 'block.set',
-          props: {style},
-          at: focusTextBlock.path,
-        }),
-        execute({
-          type: 'delete.text',
-          at: {
-            anchor: {
-              path: focusTextBlock.path,
-              offset: 0,
-            },
-            focus: {
-              path: focusTextBlock.path,
-              offset: 2,
-            },
-          },
-        }),
-      ],
-    ],
-  })
-  const automaticHr = defineBehavior({
-    on: 'insert.text',
-    guard: ({snapshot, event}) => {
-      const hrCharacter =
-        event.text === '-'
-          ? '-'
-          : event.text === '*'
-            ? '*'
-            : event.text === '_'
-              ? '_'
-              : undefined
-
-      if (hrCharacter === undefined) {
-        return false
-      }
-
-      const hrObject = config.horizontalRuleObject?.(snapshot.context)
-      const focusBlock = getFocusTextBlock(snapshot)
-      const selectionCollapsed = isSelectionCollapsed(snapshot)
-
-      if (!hrObject || !focusBlock || !selectionCollapsed) {
-        return false
-      }
-
-      const previousInlineObject = getPreviousInlineObject(snapshot)
-      const textBefore = getBlockTextBefore(snapshot)
-      const hrBlockOffsets = {
-        anchor: {
-          path: focusBlock.path,
-          offset: 0,
-        },
-        focus: {
-          path: focusBlock.path,
-          offset: 3,
-        },
-      }
-
-      if (
-        !previousInlineObject &&
-        textBefore === `${hrCharacter}${hrCharacter}`
-      ) {
-        return {hrObject, focusBlock, hrCharacter, hrBlockOffsets}
-      }
-
-      return false
-    },
-    actions: [
-      (_, {hrCharacter}) => [
-        execute({
-          type: 'insert.text',
-          text: hrCharacter,
-        }),
-      ],
-      (_, {hrObject, hrBlockOffsets}) => [
-        execute({
-          type: 'insert.block',
-          placement: 'before',
-          block: {
-            _type: hrObject.name,
-            ...(hrObject.value ?? {}),
-          },
-        }),
-        execute({
-          type: 'delete.text',
-          at: hrBlockOffsets,
-        }),
-      ],
-    ],
-  })
-  const automaticHrOnPaste = defineBehavior({
-    on: 'clipboard.paste',
-    guard: ({snapshot, event}) => {
-      const text = event.originEvent.dataTransfer.getData('text/plain')
-      const hrRegExp = /^(---)$|(___)$|(\*\*\*)$/
-      const hrCharacters = text.match(hrRegExp)?.[0]
-      const hrObject = config.horizontalRuleObject?.(snapshot.context)
-      const focusBlock = getFocusBlock(snapshot)
-
-      if (!hrCharacters || !hrObject || !focusBlock) {
-        return false
-      }
-
-      return {hrCharacters, hrObject, focusBlock}
-    },
-    actions: [
-      (_, {hrCharacters}) => [
-        execute({
-          type: 'insert.text',
-          text: hrCharacters,
-        }),
-      ],
-      ({snapshot}, {hrObject, focusBlock}) =>
-        isTextBlock(snapshot.context, focusBlock.node)
-          ? [
-              execute({
-                type: 'insert.block',
-                block: {
-                  _type: snapshot.context.schema.block.name,
-                  children: focusBlock.node.children,
-                },
-                placement: 'after',
-              }),
-              execute({
-                type: 'insert.block',
-                block: {
-                  _type: hrObject.name,
-                  ...(hrObject.value ?? {}),
-                },
-                placement: 'after',
-              }),
-              execute({
-                type: 'delete.block',
-                at: focusBlock.path,
-              }),
-            ]
-          : [
-              execute({
-                type: 'insert.block',
-                block: {
-                  _type: hrObject.name,
-                  ...(hrObject.value ?? {}),
-                },
-                placement: 'after',
-              }),
-            ],
-    ],
-  })
-  const automaticHeadingOnSpace = defineBehavior({
-    on: 'insert.text',
-    guard: ({snapshot, event}) => {
-      const isSpace = event.text === ' '
-
-      if (!isSpace) {
-        return false
-      }
-
-      const selectionCollapsed = isSelectionCollapsed(snapshot)
-      const focusTextBlock = getFocusTextBlock(snapshot)
-      const focusSpan = getFocusSpan(snapshot)
-
-      if (!selectionCollapsed || !focusTextBlock || !focusSpan) {
-        return false
-      }
-
-      const blockOffset = spanSelectionPointToBlockOffset({
-        context: snapshot.context,
-        selectionPoint: {
-          path: [
-            {_key: focusTextBlock.node._key},
-            'children',
-            {_key: focusSpan.node._key},
-          ],
-          offset: snapshot.context.selection?.focus.offset ?? 0,
-        },
-      })
-
-      if (!blockOffset) {
-        return false
-      }
-
-      const previousInlineObject = getPreviousInlineObject(snapshot)
-      const blockText = getTextBlockText(focusTextBlock.node)
-      const markdownHeadingSearch = /^#+/.exec(blockText)
-      const level = markdownHeadingSearch
-        ? markdownHeadingSearch[0].length
-        : undefined
-      const caretAtTheEndOfHeading = blockOffset.offset === level
-
-      if (previousInlineObject || !caretAtTheEndOfHeading) {
-        return false
-      }
-
-      const style =
-        level !== undefined
-          ? config.headingStyle?.({schema: snapshot.context.schema, level})
-          : undefined
-
-      if (level !== undefined && style !== undefined) {
-        return {
-          focusTextBlock,
-          style: style,
-          level,
-        }
-      }
-
-      return false
-    },
-    actions: [
-      ({event}) => [execute(event)],
-      (_, {focusTextBlock, style, level}) => [
-        execute({
-          type: 'block.unset',
-          props: ['listItem', 'level'],
-          at: focusTextBlock.path,
-        }),
-        execute({
-          type: 'block.set',
-          props: {style},
-          at: focusTextBlock.path,
-        }),
-        execute({
-          type: 'delete.text',
-          at: {
-            anchor: {
-              path: focusTextBlock.path,
-              offset: 0,
-            },
-            focus: {
-              path: focusTextBlock.path,
-              offset: level + 1,
-            },
-          },
-        }),
-      ],
-    ],
-  })
-  const clearStyleOnBackspace = defineBehavior({
-    on: 'delete.backward',
-    guard: ({snapshot}) => {
-      const selectionCollapsed = isSelectionCollapsed(snapshot)
-      const focusTextBlock = getFocusTextBlock(snapshot)
-      const focusSpan = getFocusSpan(snapshot)
-
-      if (!selectionCollapsed || !focusTextBlock || !focusSpan) {
-        return false
-      }
-
-      const atTheBeginningOfBLock =
-        focusTextBlock.node.children[0]._key === focusSpan.node._key &&
-        snapshot.context.selection?.focus.offset === 0
-
-      const defaultStyle = config.defaultStyle?.(snapshot.context)
-
-      if (
-        atTheBeginningOfBLock &&
-        defaultStyle &&
-        focusTextBlock.node.style !== defaultStyle
-      ) {
-        return {defaultStyle, focusTextBlock}
-      }
-
-      return false
-    },
-    actions: [
-      (_, {defaultStyle, focusTextBlock}) => [
-        execute({
-          type: 'block.set',
-          props: {style: defaultStyle},
-          at: focusTextBlock.path,
-        }),
-      ],
-    ],
-  })
-  const automaticListOnSpace = defineBehavior({
-    on: 'insert.text',
-    guard: ({snapshot, event}) => {
-      const isSpace = event.text === ' '
-
-      if (!isSpace) {
-        return false
-      }
-
-      const selectionCollapsed = isSelectionCollapsed(snapshot)
-      const focusTextBlock = getFocusTextBlock(snapshot)
-      const focusSpan = getFocusSpan(snapshot)
-
-      if (!selectionCollapsed || !focusTextBlock || !focusSpan) {
-        return false
-      }
-
-      const previousInlineObject = getPreviousInlineObject(snapshot)
-      const blockOffset = spanSelectionPointToBlockOffset({
-        context: snapshot.context,
-        selectionPoint: {
-          path: [
-            {_key: focusTextBlock.node._key},
-            'children',
-            {_key: focusSpan.node._key},
-          ],
-          offset: snapshot.context.selection?.focus.offset ?? 0,
-        },
-      })
-
-      if (previousInlineObject || !blockOffset) {
-        return false
-      }
-
-      const blockText = getTextBlockText(focusTextBlock.node)
-      const defaultStyle = config.defaultStyle?.(snapshot.context)
-      const looksLikeUnorderedList = /^(-|\*)/.test(blockText)
-      const unorderedListStyle = config.unorderedListStyle?.(snapshot.context)
-      const caretAtTheEndOfUnorderedList = blockOffset.offset === 1
-
-      if (
-        defaultStyle &&
-        caretAtTheEndOfUnorderedList &&
-        looksLikeUnorderedList &&
-        unorderedListStyle !== undefined
-      ) {
-        return {
-          focusTextBlock,
-          listItem: unorderedListStyle,
-          listItemLength: 1,
-          style: defaultStyle,
-        }
-      }
-
-      const looksLikeOrderedList = /^1\./.test(blockText)
-      const orderedListStyle = config.orderedListStyle?.(snapshot.context)
-      const caretAtTheEndOfOrderedList = blockOffset.offset === 2
-
-      if (
-        defaultStyle &&
-        caretAtTheEndOfOrderedList &&
-        looksLikeOrderedList &&
-        orderedListStyle !== undefined
-      ) {
-        return {
-          focusTextBlock,
-          listItem: orderedListStyle,
-          listItemLength: 2,
-          style: defaultStyle,
-        }
-      }
-
-      return false
-    },
-    actions: [
-      ({event}) => [execute(event)],
-      (_, {focusTextBlock, style, listItem, listItemLength}) => [
-        execute({
-          type: 'block.set',
-          props: {
-            listItem,
-            level: 1,
-            style,
-          },
-          at: focusTextBlock.path,
-        }),
-        execute({
-          type: 'delete.text',
-          at: {
-            anchor: {
-              path: focusTextBlock.path,
-              offset: 0,
-            },
-            focus: {
-              path: focusTextBlock.path,
-              offset: listItemLength + 1,
-            },
-          },
-        }),
-      ],
-    ],
-  })
-
-  const markdownBehaviors = [
-    automaticBlockquoteOnSpace,
-    automaticHeadingOnSpace,
-    automaticHr,
-    automaticHrOnPaste,
-    clearStyleOnBackspace,
-    automaticListOnSpace,
-  ]
-
-  return markdownBehaviors
-}

package/src/editor/plugins/createWithUtils.ts

@@ -1,52 +0,0 @@
-import {toSlateBlock} from '../../internal-utils/values'
-import type {PortableTextSlateEditor} from '../../types/editor'
-import type {EditorActor} from '../editor-machine'
-
-interface Options {
-  editorActor: EditorActor
-}
-
-/**
- * This plugin makes various util commands available in the editor
- *
- */
-export function createWithUtils({editorActor}: Options) {
-  return function withUtils(
-    editor: PortableTextSlateEditor,
-  ): PortableTextSlateEditor {
-    editor.pteCreateTextBlock = (options: {
-      decorators: Array<string>
-      listItem?: string
-      level?: number
-    }) => {
-      return toSlateBlock(
-        {
-          _type: editorActor.getSnapshot().context.schema.block.name,
-          _key: editorActor.getSnapshot().context.keyGenerator(),
-          style:
-            editorActor.getSnapshot().context.schema.styles[0].name || 'normal',
-          ...(options.listItem ? {listItem: options.listItem} : {}),
-          ...(options.level ? {level: options.level} : {}),
-          markDefs: [],
-          children: [
-            {
-              _type: 'span',
-              _key: editorActor.getSnapshot().context.keyGenerator(),
-              text: '',
-              marks: options.decorators.filter((decorator) =>
-                editorActor
-                  .getSnapshot()
-                  .context.schema.decorators.find(
-                    ({name}) => name === decorator,
-                  ),
-              ),
-            },
-          ],
-        },
-
-        {schemaTypes: editorActor.getSnapshot().context.schema},
-      )
-    }
-    return editor
-  }
-}

package/src/internal-utils/get-text-to-emphasize.test.ts

@@ -1,60 +0,0 @@
-import {expect, test} from 'vitest'
-import {getTextToBold, getTextToItalic} from './get-text-to-emphasize'
-
-test(getTextToItalic.name, () => {
-  expect(getTextToItalic('Hello *world*')).toBe('*world*')
-  expect(getTextToItalic('Hello _world_')).toBe('_world_')
-  expect(getTextToItalic('*Hello*world*')).toBe('*world*')
-  expect(getTextToItalic('_Hello_world_')).toBe('_world_')
-
-  expect(getTextToItalic('* Hello world *')).toBe(undefined)
-  expect(getTextToItalic('* Hello world*')).toBe(undefined)
-  expect(getTextToItalic('*Hello world *')).toBe(undefined)
-  expect(getTextToItalic('_ Hello world _')).toBe(undefined)
-  expect(getTextToItalic('_ Hello world_')).toBe(undefined)
-  expect(getTextToItalic('_Hello world _')).toBe(undefined)
-
-  expect(getTextToItalic('Hello *world')).toBe(undefined)
-  expect(getTextToItalic('Hello world*')).toBe(undefined)
-  expect(getTextToItalic('Hello *world* *')).toBe(undefined)
-
-  expect(getTextToItalic('_Hello*world_')).toBe('_Hello*world_')
-  expect(getTextToItalic('*Hello_world*')).toBe('*Hello_world*')
-
-  expect(getTextToItalic('*hello\nworld*')).toBe(undefined)
-  expect(getTextToItalic('_hello\nworld_')).toBe(undefined)
-
-  expect(getTextToItalic('*')).toBe(undefined)
-  expect(getTextToItalic('_')).toBe(undefined)
-  expect(getTextToItalic('**')).toBe(undefined)
-  expect(getTextToItalic('__')).toBe(undefined)
-})
-
-test(getTextToBold.name, () => {
-  expect(getTextToBold('Hello **world**')).toBe('**world**')
-  expect(getTextToBold('Hello __world__')).toBe('__world__')
-  expect(getTextToBold('**Hello**world**')).toBe('**world**')
-  expect(getTextToBold('__Hello__world__')).toBe('__world__')
-
-  expect(getTextToBold('** Hello world **')).toBe(undefined)
-  expect(getTextToBold('** Hello world**')).toBe(undefined)
-  expect(getTextToBold('**Hello world **')).toBe(undefined)
-  expect(getTextToBold('__ Hello world __')).toBe(undefined)
-  expect(getTextToBold('__ Hello world__')).toBe(undefined)
-  expect(getTextToBold('__Hello world __')).toBe(undefined)
-
-  expect(getTextToBold('Hello **world')).toBe(undefined)
-  expect(getTextToBold('Hello world**')).toBe(undefined)
-  expect(getTextToBold('Hello **world** **')).toBe(undefined)
-
-  expect(getTextToBold('__Hello**world__')).toBe('__Hello**world__')
-  expect(getTextToBold('**Hello__world**')).toBe('**Hello__world**')
-
-  expect(getTextToBold('**hello\nworld**')).toBe(undefined)
-  expect(getTextToBold('__hello\nworld__')).toBe(undefined)
-
-  expect(getTextToBold('**')).toBe(undefined)
-  expect(getTextToBold('__')).toBe(undefined)
-  expect(getTextToBold('****')).toBe(undefined)
-  expect(getTextToBold('____')).toBe(undefined)
-})

package/src/internal-utils/get-text-to-emphasize.ts

@@ -1,40 +0,0 @@
-export function createPairRegex(char: string, amount: number) {
-  // Negative lookbehind: Ensures that the matched sequence is not preceded by the same character
-  const prePrefix = `(?<!\\${char})`
-
-  // Repeats the character `amount` times
-  const prefix = `\\${char}`.repeat(Math.max(amount, 1))
-
-  // Negative lookahead: Ensures that the opening pair (**, *, etc.) is not followed by a space
-  const postPrefix = `(?!\\s)`
-
-  // Captures the content inside the pair
-  const content = `([^${char}\\n]+?)`
-
-  // Negative lookbehind: Ensures that the content is not followed by a space
-  const preSuffix = `(?<!\\s)`
-
-  // Repeats the character `amount` times
-  const suffix = `\\${char}`.repeat(Math.max(amount, 1))
-
-  // Negative lookahead: Ensures that the matched sequence is not followed by the same character
-  const postSuffix = `(?!\\${char})`
-
-  return `${prePrefix}${prefix}${postPrefix}${content}${preSuffix}${suffix}${postSuffix}`
-}
-
-const italicRegex = new RegExp(
-  `(${createPairRegex('*', 1)}|${createPairRegex('_', 1)})$`,
-)
-
-const boldRegex = new RegExp(
-  `(${createPairRegex('*', 2)}|${createPairRegex('_', 2)})$`,
-)
-
-export function getTextToItalic(text: string) {
-  return text.match(italicRegex)?.at(0)
-}
-
-export function getTextToBold(text: string) {
-  return text.match(boldRegex)?.at(0)
-}