@blade-hq/agent-react 2612.0.0-beta.2 → 2612.0.0-beta.20

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

@@ -0,0 +1,57 @@
+import { liftTarget } from '@tiptap/pm/transform'
+
+import type { RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    clearNodes: {
+      /**
+       * Normalize nodes to a simple paragraph.
+       * @example editor.commands.clearNodes()
+       */
+      clearNodes: () => ReturnType
+    }
+  }
+}
+
+export const clearNodes: RawCommands['clearNodes'] =
+  () =>
+  ({ state, tr, dispatch }) => {
+    const { selection } = tr
+    const { ranges } = selection
+
+    if (!dispatch) {
+      return true
+    }
+
+    ranges.forEach(({ $from, $to }) => {
+      state.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
+        if (node.type.isText) {
+          return
+        }
+
+        const { doc, mapping } = tr
+        const $mappedFrom = doc.resolve(mapping.map(pos))
+        const $mappedTo = doc.resolve(mapping.map(pos + node.nodeSize))
+        const nodeRange = $mappedFrom.blockRange($mappedTo)
+
+        if (!nodeRange) {
+          return
+        }
+
+        const targetLiftDepth = liftTarget(nodeRange)
+
+        if (node.type.isTextblock) {
+          const { defaultType } = $mappedFrom.parent.contentMatchAt($mappedFrom.index())
+
+          tr.setNodeMarkup(nodeRange.start, defaultType)
+        }
+
+        if (targetLiftDepth || targetLiftDepth === 0) {
+          tr.lift(nodeRange, targetLiftDepth)
+        }
+      })
+    })
+
+    return true
+  }

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

@@ -0,0 +1,22 @@
+import type { Command, RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    command: {
+      /**
+       * Define a command inline.
+       * @param fn The command function.
+       * @example
+       * editor.commands.command(({ tr, state }) => {
+       *   ...
+       *   return true
+       * })
+       */
+      command: (fn: (props: Parameters<Command>[0]) => boolean) => ReturnType
+    }
+  }
+}
+
+export const command: RawCommands['command'] = fn => props => {
+  return fn(props)
+}

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

@@ -0,0 +1,21 @@
+import { createParagraphNear as originalCreateParagraphNear } from '@tiptap/pm/commands'
+
+import type { RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    createParagraphNear: {
+      /**
+       * Create a paragraph nearby.
+       * @example editor.commands.createParagraphNear()
+       */
+      createParagraphNear: () => ReturnType
+    }
+  }
+}
+
+export const createParagraphNear: RawCommands['createParagraphNear'] =
+  () =>
+  ({ state, dispatch }) => {
+    return originalCreateParagraphNear(state, dispatch)
+  }

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

@@ -0,0 +1,36 @@
+import { TextSelection } from '@tiptap/pm/state'
+
+import type { RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    cut: {
+      /**
+       * Cuts content from a range and inserts it at a given position.
+       * @param range The range to cut.
+       * @param range.from The start position of the range.
+       * @param range.to The end position of the range.
+       * @param targetPos The position to insert the content at.
+       * @example editor.commands.cut({ from: 1, to: 3 }, 5)
+       */
+      cut: ({ from, to }: { from: number; to: number }, targetPos: number) => ReturnType
+    }
+  }
+}
+
+export const cut: RawCommands['cut'] =
+  (originRange, targetPos) =>
+  ({ editor, tr }) => {
+    const { state } = editor
+
+    const contentSlice = state.doc.slice(originRange.from, originRange.to)
+
+    tr.deleteRange(originRange.from, originRange.to)
+    const newPos = tr.mapping.map(targetPos)
+
+    tr.insert(newPos, contentSlice.content)
+
+    tr.setSelection(new TextSelection(tr.doc.resolve(Math.max(newPos - 1, 0))))
+
+    return true
+  }

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

@@ -0,0 +1,44 @@
+import type { RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    deleteCurrentNode: {
+      /**
+       * Delete the node that currently has the selection anchor.
+       * @example editor.commands.deleteCurrentNode()
+       */
+      deleteCurrentNode: () => ReturnType
+    }
+  }
+}
+
+export const deleteCurrentNode: RawCommands['deleteCurrentNode'] =
+  () =>
+  ({ tr, dispatch }) => {
+    const { selection } = tr
+    const currentNode = selection.$anchor.node()
+
+    // if there is content inside the current node, break out of this command
+    if (currentNode.content.size > 0) {
+      return false
+    }
+
+    const $pos = tr.selection.$anchor
+
+    for (let depth = $pos.depth; depth > 0; depth -= 1) {
+      const node = $pos.node(depth)
+
+      if (node.type === currentNode.type) {
+        if (dispatch) {
+          const from = $pos.before(depth)
+          const to = $pos.after(depth)
+
+          tr.delete(from, to).scrollIntoView()
+        }
+
+        return true
+      }
+    }
+
+    return false
+  }

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

@@ -0,0 +1,41 @@
+import type { NodeType } from '@tiptap/pm/model'
+
+import { getNodeType } from '../helpers/getNodeType.js'
+import type { RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    deleteNode: {
+      /**
+       * Delete a node with a given type or name.
+       * @param typeOrName The type or name of the node.
+       * @example editor.commands.deleteNode('paragraph')
+       */
+      deleteNode: (typeOrName: string | NodeType) => ReturnType
+    }
+  }
+}
+
+export const deleteNode: RawCommands['deleteNode'] =
+  typeOrName =>
+  ({ tr, state, dispatch }) => {
+    const type = getNodeType(typeOrName, state.schema)
+    const $pos = tr.selection.$anchor
+
+    for (let depth = $pos.depth; depth > 0; depth -= 1) {
+      const node = $pos.node(depth)
+
+      if (node.type === type) {
+        if (dispatch) {
+          const from = $pos.before(depth)
+          const to = $pos.after(depth)
+
+          tr.delete(from, to).scrollIntoView()
+        }
+
+        return true
+      }
+    }
+
+    return false
+  }

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

@@ -0,0 +1,26 @@
+import type { Range, RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    deleteRange: {
+      /**
+       * Delete a given range.
+       * @param range The range to delete.
+       * @example editor.commands.deleteRange({ from: 1, to: 3 })
+       */
+      deleteRange: (range: Range) => ReturnType
+    }
+  }
+}
+
+export const deleteRange: RawCommands['deleteRange'] =
+  range =>
+  ({ tr, dispatch }) => {
+    const { from, to } = range
+
+    if (dispatch) {
+      tr.delete(from, to)
+    }
+
+    return true
+  }

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

@@ -0,0 +1,21 @@
+import { deleteSelection as originalDeleteSelection } from '@tiptap/pm/commands'
+
+import type { RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    deleteSelection: {
+      /**
+       * Delete the selection, if there is one.
+       * @example editor.commands.deleteSelection()
+       */
+      deleteSelection: () => ReturnType
+    }
+  }
+}
+
+export const deleteSelection: RawCommands['deleteSelection'] =
+  () =>
+  ({ state, dispatch }) => {
+    return originalDeleteSelection(state, dispatch)
+  }

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

@@ -0,0 +1,19 @@
+import type { RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    enter: {
+      /**
+       * Trigger enter.
+       * @example editor.commands.enter()
+       */
+      enter: () => ReturnType
+    }
+  }
+}
+
+export const enter: RawCommands['enter'] =
+  () =>
+  ({ commands }) => {
+    return commands.keyboardShortcut('Enter')
+  }

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

@@ -0,0 +1,21 @@
+import { exitCode as originalExitCode } from '@tiptap/pm/commands'
+
+import type { RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    exitCode: {
+      /**
+       * Exit from a code block.
+       * @example editor.commands.exitCode()
+       */
+      exitCode: () => ReturnType
+    }
+  }
+}
+
+export const exitCode: RawCommands['exitCode'] =
+  () =>
+  ({ state, dispatch }) => {
+    return originalExitCode(state, dispatch)
+  }

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

@@ -0,0 +1,51 @@
+import type { MarkType } from '@tiptap/pm/model'
+import { TextSelection } from '@tiptap/pm/state'
+
+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> {
+    extendMarkRange: {
+      /**
+       * Extends the text selection to the current mark by type or name.
+       * @param typeOrName The type or name of the mark.
+       * @param attributes The attributes of the mark.
+       * @example editor.commands.extendMarkRange('bold')
+       * @example editor.commands.extendMarkRange('mention', { userId: "1" })
+       */
+      extendMarkRange: (
+        /**
+         * The type or name of the mark.
+         */
+        typeOrName: string | MarkType,
+
+        /**
+         * The attributes of the mark.
+         */
+        attributes?: Record<string, any>,
+      ) => ReturnType
+    }
+  }
+}
+
+export const extendMarkRange: RawCommands['extendMarkRange'] =
+  (typeOrName, attributes = {}) =>
+  ({ tr, state, dispatch }) => {
+    const type = getMarkType(typeOrName, state.schema)
+    const { doc, selection } = tr
+    const { $from, from, to } = selection
+
+    if (dispatch) {
+      const range = getMarkRange($from, type, attributes)
+
+      if (range && range.from <= from && range.to >= to) {
+        const newSelection = TextSelection.create(doc, range.from, range.to)
+
+        tr.setSelection(newSelection)
+      }
+    }
+
+    return true
+  }

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

@@ -0,0 +1,26 @@
+import type { Command, CommandProps, RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    first: {
+      /**
+       * Runs one command after the other and stops at the first which returns true.
+       * @param commands The commands to run.
+       * @example editor.commands.first([command1, command2])
+       */
+      first: (commands: Command[] | ((props: CommandProps) => Command[])) => ReturnType
+    }
+  }
+}
+
+export const first: RawCommands['first'] = commands => props => {
+  const items = typeof commands === 'function' ? commands(props) : commands
+
+  for (let i = 0; i < items.length; i += 1) {
+    if (items[i](props)) {
+      return true
+    }
+  }
+
+  return false
+}

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

@@ -0,0 +1,108 @@
+import { isTextSelection } from '../helpers/isTextSelection.js'
+import { resolveFocusPosition } from '../helpers/resolveFocusPosition.js'
+import type { FocusPosition, RawCommands } from '../types.js'
+import { isAndroid } from '../utilities/isAndroid.js'
+import { isiOS } from '../utilities/isiOS.js'
+import { isSafari } from '../utilities/isSafari.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    focus: {
+      /**
+       * Focus the editor at the given position.
+       * @param position The position to focus at.
+       * @param options.scrollIntoView Scroll the focused position into view after focusing
+       * @example editor.commands.focus()
+       * @example editor.commands.focus(32, { scrollIntoView: false })
+       */
+      focus: (
+        /**
+         * The position to focus at.
+         */
+        position?: FocusPosition,
+
+        /**
+         * Optional options
+         * @default { scrollIntoView: true }
+         */
+        options?: {
+          scrollIntoView?: boolean
+        },
+      ) => ReturnType
+    }
+  }
+}
+
+export const focus: RawCommands['focus'] =
+  (position = null, options = {}) =>
+  ({ editor, view, tr, dispatch }) => {
+    options = {
+      scrollIntoView: true,
+      ...options,
+    }
+
+    const delayedFocus = () => {
+      // focus within `requestAnimationFrame` breaks focus on iOS and Android
+      // so we have to call this
+      if (isiOS() || isAndroid()) {
+        ;(view.dom as HTMLElement).focus()
+      }
+
+      // Safari requires preventScroll to avoid the browser scrolling to the
+      // top of the editor when focus is called before the selection is set.
+      // We exclude iOS and Android since they are already handled above.
+      // see: https://github.com/ueberdosis/tiptap/issues/7318
+      if (isSafari() && !isiOS() && !isAndroid()) {
+        ;(view.dom as HTMLElement).focus({ preventScroll: true })
+      }
+
+      // For React we have to focus asynchronously. Otherwise wild things happen.
+      // see: https://github.com/ueberdosis/tiptap/issues/1520
+      requestAnimationFrame(() => {
+        if (!editor.isDestroyed) {
+          view.focus()
+
+          if (options?.scrollIntoView) {
+            editor.commands.scrollIntoView()
+          }
+        }
+      })
+    }
+
+    try {
+      if ((view.hasFocus() && position === null) || position === false) {
+        return true
+      }
+    } catch {
+      // if view.hasFocus fails (view not mounted yet)
+      // we will return false because there's nothing to focus
+      return false
+    }
+
+    // we don’t try to resolve a NodeSelection or CellSelection
+    if (dispatch && position === null && !isTextSelection(editor.state.selection)) {
+      delayedFocus()
+      return true
+    }
+
+    // pass through tr.doc instead of editor.state.doc
+    // since transactions could change the editors state before this command has been run
+    const selection = resolveFocusPosition(tr.doc, position) || editor.state.selection
+    const isSameSelection = editor.state.selection.eq(selection)
+
+    if (dispatch) {
+      if (!isSameSelection) {
+        tr.setSelection(selection)
+      }
+
+      // `tr.setSelection` resets the stored marks
+      // so we’ll restore them if the selection is the same as before
+      if (isSameSelection && tr.storedMarks) {
+        tr.setStoredMarks(tr.storedMarks)
+      }
+
+      delayedFocus()
+    }
+
+    return true
+  }

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

@@ -0,0 +1,24 @@
+import type { CommandProps, RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    forEach: {
+      /**
+       * Loop through an array of items.
+       */
+      forEach: <T>(
+        items: T[],
+        fn: (
+          item: T,
+          props: CommandProps & {
+            index: number
+          },
+        ) => boolean,
+      ) => ReturnType
+    }
+  }
+}
+
+export const forEach: RawCommands['forEach'] = (items, fn) => props => {
+  return items.every((item, index) => fn(item, { ...props, index }))
+}

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

@@ -0,0 +1,57 @@
+export * from './blur.js'
+export * from './clearContent.js'
+export * from './clearNodes.js'
+export * from './command.js'
+export * from './createParagraphNear.js'
+export * from './cut.js'
+export * from './deleteCurrentNode.js'
+export * from './deleteNode.js'
+export * from './deleteRange.js'
+export * from './deleteSelection.js'
+export * from './enter.js'
+export * from './exitCode.js'
+export * from './extendMarkRange.js'
+export * from './first.js'
+export * from './focus.js'
+export * from './forEach.js'
+export * from './insertContent.js'
+export * from './insertContentAt.js'
+export * from './join.js'
+export * from './joinItemBackward.js'
+export * from './joinItemForward.js'
+export * from './joinTextblockBackward.js'
+export * from './joinTextblockForward.js'
+export * from './keyboardShortcut.js'
+export * from './lift.js'
+export * from './liftEmptyBlock.js'
+export * from './liftListItem.js'
+export * from './newlineInCode.js'
+export * from './resetAttributes.js'
+export * from './scrollIntoView.js'
+export * from './selectAll.js'
+export * from './selectNodeBackward.js'
+export * from './selectNodeForward.js'
+export * from './selectParentNode.js'
+export * from './selectTextblockEnd.js'
+export * from './selectTextblockStart.js'
+export * from './setContent.js'
+export * from './setMark.js'
+export * from './setMeta.js'
+export * from './setNode.js'
+export * from './setNodeSelection.js'
+export * from './setTextDirection.js'
+export * from './setTextSelection.js'
+export * from './sinkListItem.js'
+export * from './splitBlock.js'
+export * from './splitListItem.js'
+export * from './toggleList.js'
+export * from './toggleMark.js'
+export * from './toggleNode.js'
+export * from './toggleWrap.js'
+export * from './undoInputRule.js'
+export * from './unsetAllMarks.js'
+export * from './unsetMark.js'
+export * from './unsetTextDirection.js'
+export * from './updateAttributes.js'
+export * from './wrapIn.js'
+export * from './wrapInList.js'

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

@@ -0,0 +1,46 @@
+import type { Fragment, Node as ProseMirrorNode, ParseOptions } from '@tiptap/pm/model'
+
+import type { Content, RawCommands } from '../types.js'
+
+export interface InsertContentOptions {
+  /**
+   * Options for parsing the content.
+   */
+  parseOptions?: ParseOptions
+
+  /**
+   * Whether to update the selection after inserting the content.
+   */
+  updateSelection?: boolean
+  applyInputRules?: boolean
+  applyPasteRules?: boolean
+}
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    insertContent: {
+      /**
+       * Insert a node or string of HTML at the current position.
+       * @example editor.commands.insertContent('<h1>Example</h1>')
+       * @example editor.commands.insertContent('<h1>Example</h1>', { updateSelection: false })
+       */
+      insertContent: (
+        /**
+         * The ProseMirror content to insert.
+         */
+        value: Content | ProseMirrorNode | Fragment,
+
+        /**
+         * Optional options
+         */
+        options?: InsertContentOptions,
+      ) => ReturnType
+    }
+  }
+}
+
+export const insertContent: RawCommands['insertContent'] =
+  (value, options) =>
+  ({ tr, commands }) => {
+    return commands.insertContentAt({ from: tr.selection.from, to: tr.selection.to }, value, options)
+  }