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

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

@@ -0,0 +1,51 @@
+import type { Range, RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    unsetTextDirection: {
+      /**
+       * Remove the text direction attribute from nodes.
+       * If no position is provided, it will use the current selection.
+       * @param position Optional position or range to remove the direction from
+       * @example editor.commands.unsetTextDirection()
+       * @example editor.commands.unsetTextDirection({ from: 0, to: 10 })
+       */
+      unsetTextDirection: (position?: number | Range) => ReturnType
+    }
+  }
+}
+
+export const unsetTextDirection: RawCommands['unsetTextDirection'] =
+  position =>
+  ({ tr, state, dispatch }) => {
+    const { selection } = state
+    let from: number
+    let to: number
+
+    if (typeof position === 'number') {
+      from = position
+      to = position
+    } else if (position && 'from' in position && 'to' in position) {
+      from = position.from
+      to = position.to
+    } else {
+      from = selection.from
+      to = selection.to
+    }
+
+    if (dispatch) {
+      tr.doc.nodesBetween(from, to, (node, pos) => {
+        if (node.isText) {
+          return
+        }
+
+        const newAttrs = { ...node.attrs }
+
+        delete newAttrs.dir
+
+        tr.setNodeMarkup(pos, undefined, newAttrs)
+      })
+    }
+
+    return true
+  }

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

@@ -0,0 +1,150 @@
+import type { Mark, MarkType, Node, NodeType } from '@tiptap/pm/model'
+import type { SelectionRange } from '@tiptap/pm/state'
+
+import { getMarkType } from '../helpers/getMarkType.js'
+import { getNodeType } from '../helpers/getNodeType.js'
+import { getSchemaTypeNameByName } from '../helpers/getSchemaTypeNameByName.js'
+import type { RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    updateAttributes: {
+      /**
+       * Update attributes of a node or mark.
+       * @param typeOrName The type or name of the node or mark.
+       * @param attributes The attributes of the node or mark.
+       * @example editor.commands.updateAttributes('mention', { userId: "2" })
+       */
+      updateAttributes: (
+        /**
+         * The type or name of the node or mark.
+         */
+        typeOrName: string | NodeType | MarkType,
+
+        /**
+         * The attributes of the node or mark.
+         */
+        attributes: Record<string, any>,
+      ) => ReturnType
+    }
+  }
+}
+
+export const updateAttributes: RawCommands['updateAttributes'] =
+  (typeOrName, attributes = {}) =>
+  ({ tr, state, dispatch }) => {
+    let nodeType: NodeType | null = null
+    let markType: MarkType | null = null
+
+    const schemaType = getSchemaTypeNameByName(
+      typeof typeOrName === 'string' ? typeOrName : typeOrName.name,
+      state.schema,
+    )
+
+    if (!schemaType) {
+      return false
+    }
+
+    if (schemaType === 'node') {
+      nodeType = getNodeType(typeOrName as NodeType, state.schema)
+    }
+
+    if (schemaType === 'mark') {
+      markType = getMarkType(typeOrName as MarkType, state.schema)
+    }
+
+    let canUpdate = false
+
+    tr.selection.ranges.forEach((range: SelectionRange) => {
+      const from = range.$from.pos
+      const to = range.$to.pos
+
+      let lastPos: number | undefined
+      let lastNode: Node | undefined
+      let trimmedFrom: number
+      let trimmedTo: number
+
+      if (tr.selection.empty) {
+        state.doc.nodesBetween(from, to, (node: Node, pos: number) => {
+          if (nodeType && nodeType === node.type) {
+            canUpdate = true
+            trimmedFrom = Math.max(pos, from)
+            trimmedTo = Math.min(pos + node.nodeSize, to)
+            lastPos = pos
+            lastNode = node
+          }
+        })
+      } else {
+        state.doc.nodesBetween(from, to, (node: Node, pos: number) => {
+          if (pos < from && nodeType && nodeType === node.type) {
+            canUpdate = true
+            trimmedFrom = Math.max(pos, from)
+            trimmedTo = Math.min(pos + node.nodeSize, to)
+            lastPos = pos
+            lastNode = node
+          }
+
+          if (pos >= from && pos <= to) {
+            if (nodeType && nodeType === node.type) {
+              canUpdate = true
+
+              if (dispatch) {
+                tr.setNodeMarkup(pos, undefined, {
+                  ...node.attrs,
+                  ...attributes,
+                })
+              }
+            }
+
+            if (markType && node.marks.length) {
+              node.marks.forEach((mark: Mark) => {
+                if (markType === mark.type) {
+                  canUpdate = true
+
+                  if (dispatch) {
+                    const trimmedFrom2 = Math.max(pos, from)
+                    const trimmedTo2 = Math.min(pos + node.nodeSize, to)
+
+                    tr.addMark(
+                      trimmedFrom2,
+                      trimmedTo2,
+                      markType.create({
+                        ...mark.attrs,
+                        ...attributes,
+                      }),
+                    )
+                  }
+                }
+              })
+            }
+          }
+        })
+      }
+
+      if (lastNode) {
+        if (lastPos !== undefined && dispatch) {
+          tr.setNodeMarkup(lastPos, undefined, {
+            ...lastNode.attrs,
+            ...attributes,
+          })
+        }
+
+        if (markType && lastNode.marks.length) {
+          lastNode.marks.forEach((mark: Mark) => {
+            if (markType === mark.type && dispatch) {
+              tr.addMark(
+                trimmedFrom,
+                trimmedTo,
+                markType.create({
+                  ...mark.attrs,
+                  ...attributes,
+                }),
+              )
+            }
+          })
+        }
+      }
+    })
+
+    return canUpdate
+  }

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

@@ -0,0 +1,27 @@
+import { wrapIn as originalWrapIn } from '@tiptap/pm/commands'
+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> {
+    wrapIn: {
+      /**
+       * Wraps nodes in another node.
+       * @param typeOrName The type or name of the node.
+       * @param attributes The attributes of the node.
+       * @example editor.commands.wrapIn('blockquote')
+       */
+      wrapIn: (typeOrName: string | NodeType, attributes?: Record<string, any>) => ReturnType
+    }
+  }
+}
+
+export const wrapIn: RawCommands['wrapIn'] =
+  (typeOrName, attributes = {}) =>
+  ({ state, dispatch }) => {
+    const type = getNodeType(typeOrName, state.schema)
+
+    return originalWrapIn(type, attributes)(state, dispatch)
+  }

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

@@ -0,0 +1,27 @@
+import type { NodeType } from '@tiptap/pm/model'
+import { wrapInList as originalWrapInList } from '@tiptap/pm/schema-list'
+
+import { getNodeType } from '../helpers/getNodeType.js'
+import type { RawCommands } from '../types.js'
+
+declare module '@tiptap/core' {
+  interface Commands<ReturnType> {
+    wrapInList: {
+      /**
+       * Wrap a node in a list.
+       * @param typeOrName The type or name of the node.
+       * @param attributes The attributes of the node.
+       * @example editor.commands.wrapInList('bulletList')
+       */
+      wrapInList: (typeOrName: string | NodeType, attributes?: Record<string, any>) => ReturnType
+    }
+  }
+}
+
+export const wrapInList: RawCommands['wrapInList'] =
+  (typeOrName, attributes = {}) =>
+  ({ state, dispatch }) => {
+    const type = getNodeType(typeOrName, state.schema)
+
+    return originalWrapInList(type, attributes)(state, dispatch)
+  }

package/node_modules/@tiptap/core/src/extensions/clipboardTextSerializer.ts

@@ -0,0 +1,44 @@
+import { Plugin, PluginKey } from '@tiptap/pm/state'
+
+import { Extension } from '../Extension.js'
+import { getTextBetween } from '../helpers/getTextBetween.js'
+import { getTextSerializersFromSchema } from '../helpers/getTextSerializersFromSchema.js'
+
+export type ClipboardTextSerializerOptions = {
+  blockSeparator?: string
+}
+
+export const ClipboardTextSerializer = Extension.create<ClipboardTextSerializerOptions>({
+  name: 'clipboardTextSerializer',
+
+  addOptions() {
+    return {
+      blockSeparator: undefined,
+    }
+  },
+
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: new PluginKey('clipboardTextSerializer'),
+        props: {
+          clipboardTextSerializer: () => {
+            const { editor } = this
+            const { state, schema } = editor
+            const { doc, selection } = state
+            const { ranges } = selection
+            const from = Math.min(...ranges.map(range => range.$from.pos))
+            const to = Math.max(...ranges.map(range => range.$to.pos))
+            const textSerializers = getTextSerializersFromSchema(schema)
+            const range = { from, to }
+
+            return getTextBetween(doc, range, {
+              ...(this.options.blockSeparator !== undefined ? { blockSeparator: this.options.blockSeparator } : {}),
+              textSerializers,
+            })
+          },
+        },
+      }),
+    ]
+  },
+})

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

@@ -0,0 +1,14 @@
+import * as commands from '../commands/index.js'
+import { Extension } from '../Extension.js'
+
+export * from '../commands/index.js'
+
+export const Commands = Extension.create({
+  name: 'commands',
+
+  addCommands() {
+    return {
+      ...commands,
+    }
+  },
+})

package/node_modules/@tiptap/core/src/extensions/delete.ts

@@ -0,0 +1,89 @@
+import { RemoveMarkStep } from '@tiptap/pm/transform'
+
+import { Extension } from '../Extension.js'
+import { combineTransactionSteps, getChangedRanges } from '../helpers/index.js'
+
+/**
+ * This extension allows you to be notified when the user deletes content you are interested in.
+ */
+export const Delete = Extension.create({
+  name: 'delete',
+
+  onUpdate({ transaction, appendedTransactions }) {
+    const callback = () => {
+      if (
+        this.editor.options.coreExtensionOptions?.delete?.filterTransaction?.(transaction) ??
+        transaction.getMeta('y-sync$')
+      ) {
+        return
+      }
+      const nextTransaction = combineTransactionSteps(transaction.before, [transaction, ...appendedTransactions])
+      const changes = getChangedRanges(nextTransaction)
+
+      changes.forEach(change => {
+        if (
+          nextTransaction.mapping.mapResult(change.oldRange.from).deletedAfter &&
+          nextTransaction.mapping.mapResult(change.oldRange.to).deletedBefore
+        ) {
+          nextTransaction.before.nodesBetween(change.oldRange.from, change.oldRange.to, (node, from) => {
+            const to = from + node.nodeSize - 2
+            const isFullyWithinRange = change.oldRange.from <= from && to <= change.oldRange.to
+
+            this.editor.emit('delete', {
+              type: 'node',
+              node,
+              from,
+              to,
+              newFrom: nextTransaction.mapping.map(from),
+              newTo: nextTransaction.mapping.map(to),
+              deletedRange: change.oldRange,
+              newRange: change.newRange,
+              partial: !isFullyWithinRange,
+              editor: this.editor,
+              transaction,
+              combinedTransform: nextTransaction,
+            })
+          })
+        }
+      })
+
+      const mapping = nextTransaction.mapping
+      nextTransaction.steps.forEach((step, index) => {
+        if (step instanceof RemoveMarkStep) {
+          const newStart = mapping.slice(index).map(step.from, -1)
+          const newEnd = mapping.slice(index).map(step.to)
+          const oldStart = mapping.invert().map(newStart, -1)
+          const oldEnd = mapping.invert().map(newEnd)
+
+          const foundBeforeMark = nextTransaction.doc.nodeAt(newStart - 1)?.marks.some(mark => mark.eq(step.mark))
+          const foundAfterMark = nextTransaction.doc.nodeAt(newEnd)?.marks.some(mark => mark.eq(step.mark))
+
+          this.editor.emit('delete', {
+            type: 'mark',
+            mark: step.mark,
+            from: step.from,
+            to: step.to,
+            deletedRange: {
+              from: oldStart,
+              to: oldEnd,
+            },
+            newRange: {
+              from: newStart,
+              to: newEnd,
+            },
+            partial: Boolean(foundAfterMark || foundBeforeMark),
+            editor: this.editor,
+            transaction,
+            combinedTransform: nextTransaction,
+          })
+        }
+      })
+    }
+
+    if (this.editor.options.coreExtensionOptions?.delete?.async ?? true) {
+      setTimeout(callback, 0)
+    } else {
+      callback()
+    }
+  },
+})

package/node_modules/@tiptap/core/src/extensions/drop.ts

@@ -0,0 +1,26 @@
+import { Plugin, PluginKey } from '@tiptap/pm/state'
+
+import { Extension } from '../Extension.js'
+
+export const Drop = Extension.create({
+  name: 'drop',
+
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: new PluginKey('tiptapDrop'),
+
+        props: {
+          handleDrop: (_, e, slice, moved) => {
+            this.editor.emit('drop', {
+              editor: this.editor,
+              event: e,
+              slice,
+              moved,
+            })
+          },
+        },
+      }),
+    ]
+  },
+})

package/node_modules/@tiptap/core/src/extensions/editable.ts

@@ -0,0 +1,18 @@
+import { Plugin, PluginKey } from '@tiptap/pm/state'
+
+import { Extension } from '../Extension.js'
+
+export const Editable = Extension.create({
+  name: 'editable',
+
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: new PluginKey('editable'),
+        props: {
+          editable: () => this.editor.options.editable,
+        },
+      }),
+    ]
+  },
+})

package/node_modules/@tiptap/core/src/extensions/focusEvents.ts

@@ -0,0 +1,41 @@
+import { Plugin, PluginKey } from '@tiptap/pm/state'
+
+import { Extension } from '../Extension.js'
+
+export const focusEventsPluginKey = new PluginKey('focusEvents')
+
+export const FocusEvents = Extension.create({
+  name: 'focusEvents',
+
+  addProseMirrorPlugins() {
+    const { editor } = this
+
+    return [
+      new Plugin({
+        key: focusEventsPluginKey,
+        props: {
+          handleDOMEvents: {
+            focus: (view, event: Event) => {
+              editor.isFocused = true
+
+              const transaction = editor.state.tr.setMeta('focus', { event }).setMeta('addToHistory', false)
+
+              view.dispatch(transaction)
+
+              return false
+            },
+            blur: (view, event: Event) => {
+              editor.isFocused = false
+
+              const transaction = editor.state.tr.setMeta('blur', { event }).setMeta('addToHistory', false)
+
+              view.dispatch(transaction)
+
+              return false
+            },
+          },
+        },
+      }),
+    ]
+  },
+})

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

@@ -0,0 +1,10 @@
+export { ClipboardTextSerializer } from './clipboardTextSerializer.js'
+export { Commands } from './commands.js'
+export { Delete } from './delete.js'
+export { Drop } from './drop.js'
+export { Editable } from './editable.js'
+export { FocusEvents, focusEventsPluginKey } from './focusEvents.js'
+export { Keymap } from './keymap.js'
+export { Paste } from './paste.js'
+export { Tabindex } from './tabindex.js'
+export { TextDirection } from './textDirection.js'

package/node_modules/@tiptap/core/src/extensions/keymap.ts

@@ -0,0 +1,160 @@
+import { Plugin, PluginKey, Selection } from '@tiptap/pm/state'
+
+import { CommandManager } from '../CommandManager.js'
+import { Extension } from '../Extension.js'
+import { createChainableState } from '../helpers/createChainableState.js'
+import { isNodeEmpty } from '../helpers/isNodeEmpty.js'
+import { isiOS } from '../utilities/isiOS.js'
+import { isMacOS } from '../utilities/isMacOS.js'
+
+export const Keymap = Extension.create({
+  name: 'keymap',
+
+  addKeyboardShortcuts() {
+    const handleBackspace = () =>
+      this.editor.commands.first(({ commands }) => [
+        () => commands.undoInputRule(),
+
+        // maybe convert first text block node to default node
+        () =>
+          commands.command(({ tr }) => {
+            const { selection, doc } = tr
+            const { empty, $anchor } = selection
+            const { pos, parent } = $anchor
+            const $parentPos = $anchor.parent.isTextblock && pos > 0 ? tr.doc.resolve(pos - 1) : $anchor
+            const parentIsIsolating = $parentPos.parent.type.spec.isolating
+
+            const parentPos = $anchor.pos - $anchor.parentOffset
+
+            const isAtStart =
+              parentIsIsolating && $parentPos.parent.childCount === 1
+                ? parentPos === $anchor.pos
+                : Selection.atStart(doc).from === pos
+
+            if (
+              !empty ||
+              !parent.type.isTextblock ||
+              parent.textContent.length ||
+              !isAtStart ||
+              (isAtStart && $anchor.parent.type.name === 'paragraph') // prevent clearNodes when no nodes to clear, otherwise history stack is appended
+            ) {
+              return false
+            }
+
+            return commands.clearNodes()
+          }),
+
+        () => commands.deleteSelection(),
+        () => commands.joinBackward(),
+        () => commands.selectNodeBackward(),
+      ])
+
+    const handleDelete = () =>
+      this.editor.commands.first(({ commands }) => [
+        () => commands.deleteSelection(),
+        () => commands.deleteCurrentNode(),
+        () => commands.joinForward(),
+        () => commands.selectNodeForward(),
+      ])
+
+    const handleEnter = () =>
+      this.editor.commands.first(({ commands }) => [
+        () => commands.newlineInCode(),
+        () => commands.createParagraphNear(),
+        () => commands.liftEmptyBlock(),
+        () => commands.splitBlock(),
+      ])
+
+    const baseKeymap = {
+      Enter: handleEnter,
+      'Mod-Enter': () => this.editor.commands.exitCode(),
+      Backspace: handleBackspace,
+      'Mod-Backspace': handleBackspace,
+      'Shift-Backspace': handleBackspace,
+      Delete: handleDelete,
+      'Mod-Delete': handleDelete,
+      'Mod-a': () => this.editor.commands.selectAll(),
+    }
+
+    const pcKeymap = {
+      ...baseKeymap,
+    }
+
+    const macKeymap = {
+      ...baseKeymap,
+      'Ctrl-h': handleBackspace,
+      'Alt-Backspace': handleBackspace,
+      'Ctrl-d': handleDelete,
+      'Ctrl-Alt-Backspace': handleDelete,
+      'Alt-Delete': handleDelete,
+      'Alt-d': handleDelete,
+      'Ctrl-a': () => this.editor.commands.selectTextblockStart(),
+      'Ctrl-e': () => this.editor.commands.selectTextblockEnd(),
+    }
+
+    if (isiOS() || isMacOS()) {
+      return macKeymap
+    }
+
+    return pcKeymap
+  },
+
+  addProseMirrorPlugins() {
+    return [
+      // With this plugin we check if the whole document was selected and deleted.
+      // In this case we will additionally call `clearNodes()` to convert e.g. a heading
+      // to a paragraph if necessary.
+      // This is an alternative to ProseMirror's `AllSelection`, which doesn’t work well
+      // with many other commands.
+      new Plugin({
+        key: new PluginKey('clearDocument'),
+        appendTransaction: (transactions, oldState, newState) => {
+          if (transactions.some(tr => tr.getMeta('composition'))) {
+            return
+          }
+
+          const docChanges = transactions.some(transaction => transaction.docChanged) && !oldState.doc.eq(newState.doc)
+
+          const ignoreTr = transactions.some(transaction => transaction.getMeta('preventClearDocument'))
+
+          if (!docChanges || ignoreTr) {
+            return
+          }
+
+          const { empty, from, to } = oldState.selection
+          const allFrom = Selection.atStart(oldState.doc).from
+          const allEnd = Selection.atEnd(oldState.doc).to
+          const allWasSelected = from === allFrom && to === allEnd
+
+          if (empty || !allWasSelected) {
+            return
+          }
+
+          const isEmpty = isNodeEmpty(newState.doc)
+
+          if (!isEmpty) {
+            return
+          }
+
+          const tr = newState.tr
+          const state = createChainableState({
+            state: newState,
+            transaction: tr,
+          })
+          const { commands } = new CommandManager({
+            editor: this.editor,
+            state,
+          })
+
+          commands.clearNodes()
+
+          if (!tr.steps.length) {
+            return
+          }
+
+          return tr
+        },
+      }),
+    ]
+  },
+})

package/node_modules/@tiptap/core/src/extensions/paste.ts

@@ -0,0 +1,25 @@
+import { Plugin, PluginKey } from '@tiptap/pm/state'
+
+import { Extension } from '../Extension.js'
+
+export const Paste = Extension.create({
+  name: 'paste',
+
+  addProseMirrorPlugins() {
+    return [
+      new Plugin({
+        key: new PluginKey('tiptapPaste'),
+
+        props: {
+          handlePaste: (_view, e, slice) => {
+            this.editor.emit('paste', {
+              editor: this.editor,
+              event: e,
+              slice,
+            })
+          },
+        },
+      }),
+    ]
+  },
+})