@blade-hq/agent-react 2612.0.0-beta.0 → 2612.0.0-beta.10

package/node_modules/@tiptap/core/src/commands/splitBlock.ts

@@ -0,0 +1,115 @@
+import type { EditorState } from '@tiptap/pm/state'
+import { NodeSelection, TextSelection } from '@tiptap/pm/state'
+import { canSplit } from '@tiptap/pm/transform'
+
+import { defaultBlockAt } from '../helpers/defaultBlockAt.js'
+import { getSplittedAttributes } from '../helpers/getSplittedAttributes.js'
+import type { RawCommands } from '../types.js'
+
+function ensureMarks(state: EditorState, splittableMarks?: string[]) {
+  const marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks())
+
+  if (marks) {
+    const filteredMarks = marks.filter(mark => splittableMarks?.includes(mark.type.name))
+
+    state.tr.ensureMarks(filteredMarks)
+  }
+}
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    splitBlock: {
+      /**
+       * Forks a new node from an existing node.
+       * @param options.keepMarks Keep marks from the previous node.
+       * @example editor.commands.splitBlock()
+       * @example editor.commands.splitBlock({ keepMarks: true })
+       */
+      splitBlock: (options?: { keepMarks?: boolean }) => ReturnType
+    }
+  }
+}
+
+export const splitBlock: RawCommands['splitBlock'] =
+  ({ keepMarks = true } = {}) =>
+  ({ tr, state, dispatch, editor }) => {
+    const { selection, doc } = tr
+    const { $from, $to } = selection
+    const extensionAttributes = editor.extensionManager.attributes
+    const newAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs)
+
+    if (selection instanceof NodeSelection && selection.node.isBlock) {
+      if (!$from.parentOffset || !canSplit(doc, $from.pos)) {
+        return false
+      }
+
+      if (dispatch) {
+        if (keepMarks) {
+          ensureMarks(state, editor.extensionManager.splittableMarks)
+        }
+
+        tr.split($from.pos).scrollIntoView()
+      }
+
+      return true
+    }
+
+    if (!$from.parent.isBlock) {
+      return false
+    }
+
+    const atEnd = $to.parentOffset === $to.parent.content.size
+
+    const deflt = $from.depth === 0 ? undefined : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)))
+
+    let types =
+      atEnd && deflt
+        ? [
+            {
+              type: deflt,
+              attrs: newAttributes,
+            },
+          ]
+        : undefined
+
+    let can = canSplit(tr.doc, tr.mapping.map($from.pos), 1, types)
+
+    if (!types && !can && canSplit(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : undefined)) {
+      can = true
+      types = deflt
+        ? [
+            {
+              type: deflt,
+              attrs: newAttributes,
+            },
+          ]
+        : undefined
+    }
+
+    if (dispatch) {
+      if (can) {
+        if (selection instanceof TextSelection) {
+          tr.deleteSelection()
+        }
+
+        tr.split(tr.mapping.map($from.pos), 1, types)
+
+        if (deflt && !atEnd && !$from.parentOffset && $from.parent.type !== deflt) {
+          const first = tr.mapping.map($from.before())
+          const $first = tr.doc.resolve(first)
+
+          if ($from.node(-1).canReplaceWith($first.index(), $first.index() + 1, deflt)) {
+            tr.setNodeMarkup(tr.mapping.map($from.before()), deflt)
+          }
+        }
+      }
+
+      if (keepMarks) {
+        ensureMarks(state, editor.extensionManager.splittableMarks)
+      }
+
+      tr.scrollIntoView()
+    }
+
+    return can
+  }

package/node_modules/@tiptap/core/src/commands/splitListItem.ts

@@ -0,0 +1,149 @@
+import type { Node as ProseMirrorNode, NodeType } from '@tiptap/pm/model'
+import { Fragment, Slice } from '@tiptap/pm/model'
+import { TextSelection } from '@tiptap/pm/state'
+import { canSplit } from '@tiptap/pm/transform'
+
+import { getNodeType } from '../helpers/getNodeType.js'
+import { getSplittedAttributes } from '../helpers/getSplittedAttributes.js'
+import type { RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    splitListItem: {
+      /**
+       * Splits one list item into two list items.
+       * @param typeOrName The type or name of the node.
+       * @param overrideAttrs The attributes to ensure on the new node.
+       * @example editor.commands.splitListItem('listItem')
+       */
+      splitListItem: (typeOrName: string | NodeType, overrideAttrs?: Record<string, any>) => ReturnType
+    }
+  }
+}
+
+export const splitListItem: RawCommands['splitListItem'] =
+  (typeOrName, overrideAttrs = {}) =>
+  ({ tr, state, dispatch, editor }) => {
+    const type = getNodeType(typeOrName, state.schema)
+    const { $from, $to } = state.selection
+
+    // @ts-ignore
+    // eslint-disable-next-line
+    const node: ProseMirrorNode = state.selection.node
+
+    if ((node && node.isBlock) || $from.depth < 2 || !$from.sameParent($to)) {
+      return false
+    }
+
+    const grandParent = $from.node(-1)
+
+    if (grandParent.type !== type) {
+      return false
+    }
+
+    const extensionAttributes = editor.extensionManager.attributes
+
+    if ($from.parent.content.size === 0 && $from.node(-1).childCount === $from.indexAfter(-1)) {
+      // In an empty block. If this is a nested list, the wrapping
+      // list item should be split. Otherwise, bail out and let next
+      // command handle lifting.
+      if ($from.depth === 2 || $from.node(-3).type !== type || $from.index(-2) !== $from.node(-2).childCount - 1) {
+        return false
+      }
+
+      if (dispatch) {
+        let wrap = Fragment.empty
+        // eslint-disable-next-line
+        const depthBefore = $from.index(-1) ? 1 : $from.index(-2) ? 2 : 3
+
+        // Build a fragment containing empty versions of the structure
+        // from the outer list item to the parent node of the cursor
+        for (let d = $from.depth - depthBefore; d >= $from.depth - 3; d -= 1) {
+          wrap = Fragment.from($from.node(d).copy(wrap))
+        }
+
+        const depthAfter =
+          // eslint-disable-next-line no-nested-ternary
+          $from.indexAfter(-1) < $from.node(-2).childCount
+            ? 1
+            : $from.indexAfter(-2) < $from.node(-3).childCount
+              ? 2
+              : 3
+
+        // Add a second list item with an empty default start node
+        const newNextTypeAttributes = {
+          ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
+          ...overrideAttrs,
+        }
+        const nextType = type.contentMatch.defaultType?.createAndFill(newNextTypeAttributes) || undefined
+
+        wrap = wrap.append(Fragment.from(type.createAndFill(null, nextType) || undefined))
+
+        const start = $from.before($from.depth - (depthBefore - 1))
+
+        tr.replace(start, $from.after(-depthAfter), new Slice(wrap, 4 - depthBefore, 0))
+
+        let sel = -1
+
+        tr.doc.nodesBetween(start, tr.doc.content.size, (n, pos) => {
+          if (sel > -1) {
+            return false
+          }
+
+          if (n.isTextblock && n.content.size === 0) {
+            sel = pos + 1
+          }
+        })
+
+        if (sel > -1) {
+          tr.setSelection(TextSelection.near(tr.doc.resolve(sel)))
+        }
+
+        tr.scrollIntoView()
+      }
+
+      return true
+    }
+
+    const nextType = $to.pos === $from.end() ? grandParent.contentMatchAt(0).defaultType : null
+
+    const newTypeAttributes = {
+      ...getSplittedAttributes(extensionAttributes, grandParent.type.name, grandParent.attrs),
+      ...overrideAttrs,
+    }
+    const newNextTypeAttributes = {
+      ...getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs),
+      ...overrideAttrs,
+    }
+
+    tr.delete($from.pos, $to.pos)
+
+    const types = nextType
+      ? [
+          { type, attrs: newTypeAttributes },
+          { type: nextType, attrs: newNextTypeAttributes },
+        ]
+      : [{ type, attrs: newTypeAttributes }]
+
+    if (!canSplit(tr.doc, $from.pos, 2)) {
+      return false
+    }
+
+    if (dispatch) {
+      const { selection, storedMarks } = state
+      const { splittableMarks } = editor.extensionManager
+      const marks = storedMarks || (selection.$to.parentOffset && selection.$from.marks())
+
+      tr.split($from.pos, 2, types).scrollIntoView()
+
+      if (!marks || !dispatch) {
+        return true
+      }
+
+      const filteredMarks = marks.filter(mark => splittableMarks.includes(mark.type.name))
+
+      tr.ensureMarks(filteredMarks)
+    }
+
+    return true
+  }

package/node_modules/@tiptap/core/src/commands/toggleList.ts

@@ -0,0 +1,159 @@
+import type { NodeType } from '@tiptap/pm/model'
+import type { Transaction } from '@tiptap/pm/state'
+import { canJoin } from '@tiptap/pm/transform'
+
+import { findParentNode } from '../helpers/findParentNode.js'
+import { getNodeType } from '../helpers/getNodeType.js'
+import { isList } from '../helpers/isList.js'
+import type { RawCommands } from '../types.js'
+
+const joinListBackwards = (tr: Transaction, listType: NodeType): boolean => {
+  const list = findParentNode(node => node.type === listType)(tr.selection)
+
+  if (!list) {
+    return true
+  }
+
+  const before = tr.doc.resolve(Math.max(0, list.pos - 1)).before(list.depth)
+
+  if (before === undefined) {
+    return true
+  }
+
+  const nodeBefore = tr.doc.nodeAt(before)
+  const canJoinBackwards = list.node.type === nodeBefore?.type && canJoin(tr.doc, list.pos)
+
+  if (!canJoinBackwards) {
+    return true
+  }
+
+  tr.join(list.pos)
+
+  return true
+}
+
+const joinListForwards = (tr: Transaction, listType: NodeType): boolean => {
+  const list = findParentNode(node => node.type === listType)(tr.selection)
+
+  if (!list) {
+    return true
+  }
+
+  const after = tr.doc.resolve(list.start).after(list.depth)
+
+  if (after === undefined) {
+    return true
+  }
+
+  const nodeAfter = tr.doc.nodeAt(after)
+  const canJoinForwards = list.node.type === nodeAfter?.type && canJoin(tr.doc, after)
+
+  if (!canJoinForwards) {
+    return true
+  }
+
+  tr.join(after)
+
+  return true
+}
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    toggleList: {
+      /**
+       * Toggle between different list types.
+       * @param listTypeOrName The type or name of the list.
+       * @param itemTypeOrName The type or name of the list item.
+       * @param keepMarks Keep marks when toggling.
+       * @param attributes Attributes for the new list.
+       * @example editor.commands.toggleList('bulletList', 'listItem')
+       */
+      toggleList: (
+        listTypeOrName: string | NodeType,
+        itemTypeOrName: string | NodeType,
+        keepMarks?: boolean,
+        attributes?: Record<string, any>,
+      ) => ReturnType
+    }
+  }
+}
+
+export const toggleList: RawCommands['toggleList'] =
+  (listTypeOrName, itemTypeOrName, keepMarks, attributes = {}) =>
+  ({ editor, tr, state, dispatch, chain, commands, can }) => {
+    const { extensions, splittableMarks } = editor.extensionManager
+    const listType = getNodeType(listTypeOrName, state.schema)
+    const itemType = getNodeType(itemTypeOrName, state.schema)
+    const { selection, storedMarks } = state
+    const { $from, $to } = selection
+    const range = $from.blockRange($to)
+
+    const marks = storedMarks || (selection.$to.parentOffset && selection.$from.marks())
+
+    if (!range) {
+      return false
+    }
+
+    const parentList = findParentNode(node => isList(node.type.name, extensions))(selection)
+
+    if (range.depth >= 1 && parentList && range.depth - parentList.depth <= 1) {
+      // remove list
+      if (parentList.node.type === listType) {
+        return commands.liftListItem(itemType)
+      }
+
+      // change list type
+      if (isList(parentList.node.type.name, extensions) && listType.validContent(parentList.node.content) && dispatch) {
+        return chain()
+          .command(() => {
+            tr.setNodeMarkup(parentList.pos, listType)
+
+            return true
+          })
+          .command(() => joinListBackwards(tr, listType))
+          .command(() => joinListForwards(tr, listType))
+          .run()
+      }
+    }
+    if (!keepMarks || !marks || !dispatch) {
+      return (
+        chain()
+          // try to convert node to default node if needed
+          .command(() => {
+            const canWrapInList = can().wrapInList(listType, attributes)
+
+            if (canWrapInList) {
+              return true
+            }
+
+            return commands.clearNodes()
+          })
+          .wrapInList(listType, attributes)
+          .command(() => joinListBackwards(tr, listType))
+          .command(() => joinListForwards(tr, listType))
+          .run()
+      )
+    }
+
+    return (
+      chain()
+        // try to convert node to default node if needed
+        .command(() => {
+          const canWrapInList = can().wrapInList(listType, attributes)
+
+          const filteredMarks = marks.filter(mark => splittableMarks.includes(mark.type.name))
+
+          tr.ensureMarks(filteredMarks)
+
+          if (canWrapInList) {
+            return true
+          }
+
+          return commands.clearNodes()
+        })
+        .wrapInList(listType, attributes)
+        .command(() => joinListBackwards(tr, listType))
+        .command(() => joinListForwards(tr, listType))
+        .run()
+    )
+  }

package/node_modules/@tiptap/core/src/commands/toggleMark.ts

@@ -0,0 +1,51 @@
+import type { MarkType } from '@tiptap/pm/model'
+
+import { getMarkType } from '../helpers/getMarkType.js'
+import { isMarkActive } from '../helpers/isMarkActive.js'
+import type { RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    toggleMark: {
+      /**
+       * Toggle a mark on and off.
+       * @param typeOrName The mark type or name.
+       * @param attributes The attributes of the mark.
+       * @param options.extendEmptyMarkRange Removes the mark even across the current selection. Defaults to `false`.
+       * @example editor.commands.toggleMark('bold')
+       */
+      toggleMark: (
+        /**
+         * The mark type or name.
+         */
+        typeOrName: string | MarkType,
+
+        /**
+         * The attributes of the mark.
+         */
+        attributes?: Record<string, any>,
+
+        options?: {
+          /**
+           * Removes the mark even across the current selection. Defaults to `false`.
+           */
+          extendEmptyMarkRange?: boolean
+        },
+      ) => ReturnType
+    }
+  }
+}
+
+export const toggleMark: RawCommands['toggleMark'] =
+  (typeOrName, attributes = {}, options = {}) =>
+  ({ state, commands }) => {
+    const { extendEmptyMarkRange = false } = options
+    const type = getMarkType(typeOrName, state.schema)
+    const isActive = isMarkActive(state, type, attributes)
+
+    if (isActive) {
+      return commands.unsetMark(type, { extendEmptyMarkRange })
+    }
+
+    return commands.setMark(type, attributes)
+  }

package/node_modules/@tiptap/core/src/commands/toggleNode.ts

@@ -0,0 +1,47 @@
+import type { NodeType } from '@tiptap/pm/model'
+
+import { getNodeType } from '../helpers/getNodeType.js'
+import { isNodeActive } from '../helpers/isNodeActive.js'
+import type { RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    toggleNode: {
+      /**
+       * Toggle a node with another node.
+       * @param typeOrName The type or name of the node.
+       * @param toggleTypeOrName The type or name of the node to toggle.
+       * @param attributes The attributes of the node.
+       * @example editor.commands.toggleNode('heading', 'paragraph')
+       */
+      toggleNode: (
+        typeOrName: string | NodeType,
+        toggleTypeOrName: string | NodeType,
+        attributes?: Record<string, any>,
+      ) => ReturnType
+    }
+  }
+}
+
+export const toggleNode: RawCommands['toggleNode'] =
+  (typeOrName, toggleTypeOrName, attributes = {}) =>
+  ({ state, commands }) => {
+    const type = getNodeType(typeOrName, state.schema)
+    const toggleType = getNodeType(toggleTypeOrName, state.schema)
+    const isActive = isNodeActive(state, type, attributes)
+
+    let attributesToCopy: Record<string, any> | undefined
+
+    if (state.selection.$anchor.sameParent(state.selection.$head)) {
+      // only copy attributes if the selection is pointing to a node of the same type
+      attributesToCopy = state.selection.$anchor.parent.attrs
+    }
+
+    if (isActive) {
+      return commands.setNode(toggleType, attributesToCopy)
+    }
+
+    // If the node is not active, we want to set the new node type with the given attributes
+    // Copying over the attributes from the current node if the selection is pointing to a node of the same type
+    return commands.setNode(type, { ...attributesToCopy, ...attributes })
+  }

package/node_modules/@tiptap/core/src/commands/toggleWrap.ts

@@ -0,0 +1,32 @@
+import type { NodeType } from '@tiptap/pm/model'
+
+import { getNodeType } from '../helpers/getNodeType.js'
+import { isNodeActive } from '../helpers/isNodeActive.js'
+import type { RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    toggleWrap: {
+      /**
+       * Wraps nodes in another node, or removes an existing wrap.
+       * @param typeOrName The type or name of the node.
+       * @param attributes The attributes of the node.
+       * @example editor.commands.toggleWrap('blockquote')
+       */
+      toggleWrap: (typeOrName: string | NodeType, attributes?: Record<string, any>) => ReturnType
+    }
+  }
+}
+
+export const toggleWrap: RawCommands['toggleWrap'] =
+  (typeOrName, attributes = {}) =>
+  ({ state, commands }) => {
+    const type = getNodeType(typeOrName, state.schema)
+    const isActive = isNodeActive(state, type, attributes)
+
+    if (isActive) {
+      return commands.lift(type)
+    }
+
+    return commands.wrapIn(type, attributes)
+  }

package/node_modules/@tiptap/core/src/commands/undoInputRule.ts

@@ -0,0 +1,49 @@
+import type { RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    undoInputRule: {
+      /**
+       * Undo an input rule.
+       * @example editor.commands.undoInputRule()
+       */
+      undoInputRule: () => ReturnType
+    }
+  }
+}
+
+export const undoInputRule: RawCommands['undoInputRule'] =
+  () =>
+  ({ state, dispatch }) => {
+    const plugins = state.plugins
+
+    for (let i = 0; i < plugins.length; i += 1) {
+      const plugin = plugins[i]
+      let undoable
+
+      // @ts-ignore
+      // eslint-disable-next-line
+      if (plugin.spec.isInputRules && (undoable = plugin.getState(state))) {
+        if (dispatch) {
+          const tr = state.tr
+          const toUndo = undoable.transform
+
+          for (let j = toUndo.steps.length - 1; j >= 0; j -= 1) {
+            tr.step(toUndo.steps[j].invert(toUndo.docs[j]))
+          }
+
+          if (undoable.text) {
+            const marks = tr.doc.resolve(undoable.from).marks()
+
+            tr.replaceWith(undoable.from, undoable.to, state.schema.text(undoable.text, marks))
+          } else {
+            tr.delete(undoable.from, undoable.to)
+          }
+        }
+
+        return true
+      }
+    }
+
+    return false
+  }

package/node_modules/@tiptap/core/src/commands/unsetAllMarks.ts

@@ -0,0 +1,32 @@
+import type { RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    unsetAllMarks: {
+      /**
+       * Remove all marks in the current selection.
+       * @example editor.commands.unsetAllMarks()
+       */
+      unsetAllMarks: () => ReturnType
+    }
+  }
+}
+
+export const unsetAllMarks: RawCommands['unsetAllMarks'] =
+  () =>
+  ({ tr, dispatch }) => {
+    const { selection } = tr
+    const { empty, ranges } = selection
+
+    if (empty) {
+      return true
+    }
+
+    if (dispatch) {
+      ranges.forEach(range => {
+        tr.removeMark(range.$from.pos, range.$to.pos)
+      })
+    }
+
+    return true
+  }

package/node_modules/@tiptap/core/src/commands/unsetMark.ts

@@ -0,0 +1,65 @@
+import type { MarkType } from '@tiptap/pm/model'
+
+import { getMarkRange } from '../helpers/getMarkRange.js'
+import { getMarkType } from '../helpers/getMarkType.js'
+import type { RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    unsetMark: {
+      /**
+       * Remove all marks in the current selection.
+       * @param typeOrName The mark type or name.
+       * @param options.extendEmptyMarkRange Removes the mark even across the current selection. Defaults to `false`.
+       * @example editor.commands.unsetMark('bold')
+       */
+      unsetMark: (
+        /**
+         * The mark type or name.
+         */
+        typeOrName: string | MarkType,
+
+        options?: {
+          /**
+           * Removes the mark even across the current selection. Defaults to `false`.
+           */
+          extendEmptyMarkRange?: boolean
+        },
+      ) => ReturnType
+    }
+  }
+}
+
+export const unsetMark: RawCommands['unsetMark'] =
+  (typeOrName, options = {}) =>
+  ({ tr, state, dispatch }) => {
+    const { extendEmptyMarkRange = false } = options
+    const { selection } = tr
+    const type = getMarkType(typeOrName, state.schema)
+    const { $from, empty, ranges } = selection
+
+    if (!dispatch) {
+      return true
+    }
+
+    if (empty && extendEmptyMarkRange) {
+      let { from, to } = selection
+      const attrs = $from.marks().find(mark => mark.type === type)?.attrs
+      const range = getMarkRange($from, type, attrs)
+
+      if (range) {
+        from = range.from
+        to = range.to
+      }
+
+      tr.removeMark(from, to, type)
+    } else {
+      ranges.forEach(range => {
+        tr.removeMark(range.$from.pos, range.$to.pos, type)
+      })
+    }
+
+    tr.removeStoredMark(type)
+
+    return true
+  }