@blade-hq/agent-react 2612.0.0-beta.5 → 2612.0.0-beta.7

package/node_modules/@tiptap/core/src/helpers/getAttributesFromExtensions.ts

@@ -0,0 +1,122 @@
+import type { MarkConfig, NodeConfig } from '../index.js'
+import type { AnyConfig, Attribute, Attributes, ExtensionAttribute, Extensions } from '../types.js'
+import { getExtensionField } from './getExtensionField.js'
+import { splitExtensions } from './splitExtensions.js'
+
+/**
+ * Get a list of all extension attributes defined in `addAttribute` and `addGlobalAttribute`.
+ * @param extensions List of extensions
+ */
+export function getAttributesFromExtensions(extensions: Extensions): ExtensionAttribute[] {
+  const extensionAttributes: ExtensionAttribute[] = []
+  const { nodeExtensions, markExtensions } = splitExtensions(extensions)
+  const nodeAndMarkExtensions = [...nodeExtensions, ...markExtensions]
+  const defaultAttribute: Required<Omit<Attribute, 'validate'>> & Pick<Attribute, 'validate'> = {
+    default: null,
+    validate: undefined,
+    rendered: true,
+    renderHTML: null,
+    parseHTML: null,
+    keepOnSplit: true,
+    isRequired: false,
+  }
+
+  // Precompute lists of extension types for global attribute resolution
+  const nodeExtensionTypes = nodeExtensions.filter(ext => ext.name !== 'text').map(ext => ext.name)
+  const markExtensionTypes = markExtensions.map(ext => ext.name)
+  const allExtensionTypes = [...nodeExtensionTypes, ...markExtensionTypes]
+
+  extensions.forEach(extension => {
+    const context = {
+      name: extension.name,
+      options: extension.options,
+      storage: extension.storage,
+      extensions: nodeAndMarkExtensions,
+    }
+
+    const addGlobalAttributes = getExtensionField<AnyConfig['addGlobalAttributes']>(
+      extension,
+      'addGlobalAttributes',
+      context,
+    )
+
+    if (!addGlobalAttributes) {
+      return
+    }
+
+    const globalAttributes = addGlobalAttributes()
+
+    globalAttributes.forEach(globalAttribute => {
+      // Resolve the types based on the string shorthand or explicit array
+      let resolvedTypes: string[]
+      if (Array.isArray(globalAttribute.types)) {
+        resolvedTypes = globalAttribute.types
+      } else if (globalAttribute.types === '*') {
+        resolvedTypes = allExtensionTypes
+      } else if (globalAttribute.types === 'nodes') {
+        resolvedTypes = nodeExtensionTypes
+      } else if (globalAttribute.types === 'marks') {
+        resolvedTypes = markExtensionTypes
+      } else {
+        resolvedTypes = []
+      }
+
+      resolvedTypes.forEach(type => {
+        Object.entries(globalAttribute.attributes).forEach(([name, attribute]) => {
+          extensionAttributes.push({
+            type,
+            name,
+            attribute: {
+              ...defaultAttribute,
+              ...attribute,
+            },
+          })
+        })
+      })
+    })
+  })
+
+  nodeAndMarkExtensions.forEach(extension => {
+    const context = {
+      name: extension.name,
+      options: extension.options,
+      storage: extension.storage,
+    }
+
+    const addAttributes = getExtensionField<NodeConfig['addAttributes'] | MarkConfig['addAttributes']>(
+      extension,
+      'addAttributes',
+      context,
+    )
+
+    if (!addAttributes) {
+      return
+    }
+
+    // TODO: remove `as Attributes`
+    const attributes = addAttributes() as Attributes
+
+    Object.entries(attributes).forEach(([name, attribute]) => {
+      const mergedAttr = {
+        ...defaultAttribute,
+        ...attribute,
+      }
+
+      if (typeof mergedAttr?.default === 'function') {
+        mergedAttr.default = mergedAttr.default()
+      }
+
+      if (mergedAttr?.isRequired && mergedAttr?.default === undefined) {
+        delete mergedAttr.default
+      }
+
+      extensionAttributes.push({
+        type: extension.name,
+        name,
+        attribute: mergedAttr,
+      })
+    })
+  })
+
+  return extensionAttributes
+}

package/node_modules/@tiptap/core/src/helpers/getChangedRanges.ts

@@ -0,0 +1,85 @@
+import type { Step, Transform } from '@tiptap/pm/transform'
+
+import type { Range } from '../types.js'
+import { removeDuplicates } from '../utilities/removeDuplicates.js'
+
+export type ChangedRange = {
+  oldRange: Range
+  newRange: Range
+}
+
+/**
+ * Removes duplicated ranges and ranges that are
+ * fully captured by other ranges.
+ */
+function simplifyChangedRanges(changes: ChangedRange[]): ChangedRange[] {
+  const uniqueChanges = removeDuplicates(changes)
+
+  return uniqueChanges.length === 1
+    ? uniqueChanges
+    : uniqueChanges.filter((change, index) => {
+        const rest = uniqueChanges.filter((_, i) => i !== index)
+
+        return !rest.some(otherChange => {
+          return (
+            change.oldRange.from >= otherChange.oldRange.from &&
+            change.oldRange.to <= otherChange.oldRange.to &&
+            change.newRange.from >= otherChange.newRange.from &&
+            change.newRange.to <= otherChange.newRange.to
+          )
+        })
+      })
+}
+
+/**
+ * Returns a list of changed ranges
+ * based on the first and last state of all steps.
+ */
+export function getChangedRanges(transform: Transform): ChangedRange[] {
+  const { mapping, steps } = transform
+  const changes: ChangedRange[] = []
+
+  mapping.maps.forEach((stepMap, index) => {
+    const ranges: Range[] = []
+
+    // This accounts for step changes where no range was actually altered
+    // e.g. when setting a mark, node attribute, etc.
+    // @ts-ignore
+    if (!stepMap.ranges.length) {
+      const { from, to } = steps[index] as Step & {
+        from?: number
+        to?: number
+      }
+
+      if (from === undefined || to === undefined) {
+        return
+      }
+
+      ranges.push({ from, to })
+    } else {
+      stepMap.forEach((from, to) => {
+        ranges.push({ from, to })
+      })
+    }
+
+    ranges.forEach(({ from, to }) => {
+      const newStart = mapping.slice(index).map(from, -1)
+      const newEnd = mapping.slice(index).map(to)
+      const oldStart = mapping.invert().map(newStart, -1)
+      const oldEnd = mapping.invert().map(newEnd)
+
+      changes.push({
+        oldRange: {
+          from: oldStart,
+          to: oldEnd,
+        },
+        newRange: {
+          from: newStart,
+          to: newEnd,
+        },
+      })
+    })
+  })
+
+  return simplifyChangedRanges(changes)
+}

package/node_modules/@tiptap/core/src/helpers/getDebugJSON.ts

@@ -0,0 +1,54 @@
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
+
+import type { JSONContent } from '../types.js'
+
+interface DebugJSONContent extends JSONContent {
+  from: number
+  to: number
+}
+
+export function getDebugJSON(node: ProseMirrorNode, startOffset = 0): DebugJSONContent {
+  const isTopNode = node.type === node.type.schema.topNodeType
+  const increment = isTopNode ? 0 : 1
+  const from = startOffset
+  const to = from + node.nodeSize
+  const marks = node.marks.map(mark => {
+    const output: { type: string; attrs?: Record<string, any> } = {
+      type: mark.type.name,
+    }
+
+    if (Object.keys(mark.attrs).length) {
+      output.attrs = { ...mark.attrs }
+    }
+
+    return output
+  })
+  const attrs = { ...node.attrs }
+  const output: DebugJSONContent = {
+    type: node.type.name,
+    from,
+    to,
+  }
+
+  if (Object.keys(attrs).length) {
+    output.attrs = attrs
+  }
+
+  if (marks.length) {
+    output.marks = marks
+  }
+
+  if (node.content.childCount) {
+    output.content = []
+
+    node.forEach((child, offset) => {
+      output.content?.push(getDebugJSON(child, startOffset + offset + increment))
+    })
+  }
+
+  if (node.text) {
+    output.text = node.text
+  }
+
+  return output
+}

package/node_modules/@tiptap/core/src/helpers/getExtensionField.ts

@@ -0,0 +1,32 @@
+import type { ExtensionConfig } from '../Extension.js'
+import type { MarkConfig } from '../Mark.js'
+import type { NodeConfig } from '../Node.js'
+import type { AnyExtension, MaybeThisParameterType, RemoveThis } from '../types.js'
+
+/**
+ * Returns a field from an extension
+ * @param extension The Tiptap extension
+ * @param field The field, for example `renderHTML` or `priority`
+ * @param context The context object that should be passed as `this` into the function
+ * @returns The field value
+ */
+export function getExtensionField<T = any, E extends AnyExtension = any>(
+  extension: E,
+  field: keyof ExtensionConfig | keyof MarkConfig | keyof NodeConfig,
+  context?: Omit<MaybeThisParameterType<T>, 'parent'>,
+): RemoveThis<T> {
+  if (extension.config[field as keyof typeof extension.config] === undefined && extension.parent) {
+    return getExtensionField(extension.parent, field, context)
+  }
+
+  if (typeof extension.config[field as keyof typeof extension.config] === 'function') {
+    const value = (extension.config[field as keyof typeof extension.config] as any).bind({
+      ...context,
+      parent: extension.parent ? getExtensionField(extension.parent, field, context) : null,
+    })
+
+    return value
+  }
+
+  return extension.config[field as keyof typeof extension.config] as RemoveThis<T>
+}

package/node_modules/@tiptap/core/src/helpers/getHTMLFromFragment.ts

@@ -0,0 +1,13 @@
+import type { Fragment, Schema } from '@tiptap/pm/model'
+import { DOMSerializer } from '@tiptap/pm/model'
+
+export function getHTMLFromFragment(fragment: Fragment, schema: Schema): string {
+  const documentFragment = DOMSerializer.fromSchema(schema).serializeFragment(fragment)
+
+  const temporaryDocument = document.implementation.createHTMLDocument()
+  const container = temporaryDocument.createElement('div')
+
+  container.appendChild(documentFragment)
+
+  return container.innerHTML
+}

package/node_modules/@tiptap/core/src/helpers/getMarkAttributes.ts

@@ -0,0 +1,30 @@
+import type { Mark, MarkType } from '@tiptap/pm/model'
+import type { EditorState } from '@tiptap/pm/state'
+
+import { getMarkType } from './getMarkType.js'
+
+export function getMarkAttributes(state: EditorState, typeOrName: string | MarkType): Record<string, any> {
+  const type = getMarkType(typeOrName, state.schema)
+  const { from, to, empty } = state.selection
+  const marks: Mark[] = []
+
+  if (empty) {
+    if (state.storedMarks) {
+      marks.push(...state.storedMarks)
+    }
+
+    marks.push(...state.selection.$head.marks())
+  } else {
+    state.doc.nodesBetween(from, to, node => {
+      marks.push(...node.marks)
+    })
+  }
+
+  const mark = marks.find(markItem => markItem.type.name === type.name)
+
+  if (!mark) {
+    return {}
+  }
+
+  return { ...mark.attrs }
+}

package/node_modules/@tiptap/core/src/helpers/getMarkRange.ts

@@ -0,0 +1,90 @@
+import type { Mark as ProseMirrorMark, MarkType, ResolvedPos } from '@tiptap/pm/model'
+
+import type { Range } from '../types.js'
+import { objectIncludes } from '../utilities/objectIncludes.js'
+
+function findMarkInSet(
+  marks: ProseMirrorMark[],
+  type: MarkType,
+  attributes: Record<string, any> = {},
+): ProseMirrorMark | undefined {
+  return marks.find(item => {
+    return (
+      item.type === type &&
+      objectIncludes(
+        // Only check equality for the attributes that are provided
+        Object.fromEntries(Object.keys(attributes).map(k => [k, item.attrs[k]])),
+        attributes,
+      )
+    )
+  })
+}
+
+function isMarkInSet(marks: ProseMirrorMark[], type: MarkType, attributes: Record<string, any> = {}): boolean {
+  return !!findMarkInSet(marks, type, attributes)
+}
+
+/**
+ * Get the range of a mark at a resolved position.
+ */
+export function getMarkRange(
+  /**
+   * The position to get the mark range for.
+   */
+  $pos: ResolvedPos,
+  /**
+   * The mark type to get the range for.
+   */
+  type: MarkType,
+  /**
+   * The attributes to match against.
+   * If not provided, only the first mark at the position will be matched.
+   */
+  attributes?: Record<string, any>,
+): Range | void {
+  if (!$pos || !type) {
+    return
+  }
+  let start = $pos.parent.childAfter($pos.parentOffset)
+
+  // If the cursor is at the start of a text node that does not have the mark, look backward
+  if (!start.node || !start.node.marks.some(mark => mark.type === type)) {
+    start = $pos.parent.childBefore($pos.parentOffset)
+  }
+
+  // If there is no text node with the mark even backward, return undefined
+  if (!start.node || !start.node.marks.some(mark => mark.type === type)) {
+    return
+  }
+
+  // Default to only matching against the first mark's attributes
+  attributes = attributes || start.node.marks[0]?.attrs
+
+  // We now know that the cursor is either at the start, middle or end of a text node with the specified mark
+  // so we can look it up on the targeted mark
+  const mark = findMarkInSet([...start.node.marks], type, attributes)
+
+  if (!mark) {
+    return
+  }
+
+  let startIndex = start.index
+  let startPos = $pos.start() + start.offset
+  let endIndex = startIndex + 1
+  let endPos = startPos + start.node.nodeSize
+
+  while (startIndex > 0 && isMarkInSet([...$pos.parent.child(startIndex - 1).marks], type, attributes)) {
+    startIndex -= 1
+    startPos -= $pos.parent.child(startIndex).nodeSize
+  }
+
+  while (endIndex < $pos.parent.childCount && isMarkInSet([...$pos.parent.child(endIndex).marks], type, attributes)) {
+    endPos += $pos.parent.child(endIndex).nodeSize
+    endIndex += 1
+  }
+
+  return {
+    from: startPos,
+    to: endPos,
+  }
+}

package/node_modules/@tiptap/core/src/helpers/getMarkType.ts

@@ -0,0 +1,13 @@
+import type { MarkType, Schema } from '@tiptap/pm/model'
+
+export function getMarkType(nameOrType: string | MarkType, schema: Schema): MarkType {
+  if (typeof nameOrType === 'string') {
+    if (!schema.marks[nameOrType]) {
+      throw Error(`There is no mark type named '${nameOrType}'. Maybe you forgot to add the extension?`)
+    }
+
+    return schema.marks[nameOrType]
+  }
+
+  return nameOrType
+}

package/node_modules/@tiptap/core/src/helpers/getMarksBetween.ts

@@ -0,0 +1,44 @@
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
+
+import type { MarkRange } from '../types.js'
+import { getMarkRange } from './getMarkRange.js'
+
+export function getMarksBetween(from: number, to: number, doc: ProseMirrorNode): MarkRange[] {
+  const marks: MarkRange[] = []
+
+  // get all inclusive marks on empty selection
+  if (from === to) {
+    doc
+      .resolve(from)
+      .marks()
+      .forEach(mark => {
+        const $pos = doc.resolve(from)
+        const range = getMarkRange($pos, mark.type)
+
+        if (!range) {
+          return
+        }
+
+        marks.push({
+          mark,
+          ...range,
+        })
+      })
+  } else {
+    doc.nodesBetween(from, to, (node, pos) => {
+      if (!node || node?.nodeSize === undefined) {
+        return
+      }
+
+      marks.push(
+        ...node.marks.map(mark => ({
+          from: pos,
+          to: pos + node.nodeSize,
+          mark,
+        })),
+      )
+    })
+  }
+
+  return marks
+}

package/node_modules/@tiptap/core/src/helpers/getNodeAtPosition.ts

@@ -0,0 +1,29 @@
+import type { Node, NodeType } from '@tiptap/pm/model'
+import type { EditorState } from '@tiptap/pm/state'
+
+/**
+ * Finds the first node of a given type or name in the current selection.
+ * @param state The editor state.
+ * @param typeOrName The node type or name.
+ * @param pos The position to start searching from.
+ * @param maxDepth The maximum depth to search.
+ * @returns The node and the depth as an array.
+ */
+export const getNodeAtPosition = (state: EditorState, typeOrName: string | NodeType, pos: number, maxDepth = 20) => {
+  const $pos = state.doc.resolve(pos)
+
+  let currentDepth = maxDepth
+  let node: Node | null = null
+
+  while (currentDepth > 0 && node === null) {
+    const currentNode = $pos.node(currentDepth)
+
+    if (currentNode?.type.name === typeOrName) {
+      node = currentNode
+    } else {
+      currentDepth -= 1
+    }
+  }
+
+  return [node, currentDepth] as [Node | null, number]
+}

package/node_modules/@tiptap/core/src/helpers/getNodeAttributes.ts

@@ -0,0 +1,22 @@
+import type { Node, NodeType } from '@tiptap/pm/model'
+import type { EditorState } from '@tiptap/pm/state'
+
+import { getNodeType } from './getNodeType.js'
+
+export function getNodeAttributes(state: EditorState, typeOrName: string | NodeType): Record<string, any> {
+  const type = getNodeType(typeOrName, state.schema)
+  const { from, to } = state.selection
+  const nodes: Node[] = []
+
+  state.doc.nodesBetween(from, to, node => {
+    nodes.push(node)
+  })
+
+  const node = nodes.reverse().find(nodeItem => nodeItem.type.name === type.name)
+
+  if (!node) {
+    return {}
+  }
+
+  return { ...node.attrs }
+}

package/node_modules/@tiptap/core/src/helpers/getNodeType.ts

@@ -0,0 +1,13 @@
+import type { NodeType, Schema } from '@tiptap/pm/model'
+
+export function getNodeType(nameOrType: string | NodeType, schema: Schema): NodeType {
+  if (typeof nameOrType === 'string') {
+    if (!schema.nodes[nameOrType]) {
+      throw Error(`There is no node type named '${nameOrType}'. Maybe you forgot to add the extension?`)
+    }
+
+    return schema.nodes[nameOrType]
+  }
+
+  return nameOrType
+}

package/node_modules/@tiptap/core/src/helpers/getRenderedAttributes.ts

@@ -0,0 +1,23 @@
+import type { Mark, Node } from '@tiptap/pm/model'
+
+import type { ExtensionAttribute } from '../types.js'
+import { mergeAttributes } from '../utilities/mergeAttributes.js'
+
+export function getRenderedAttributes(
+  nodeOrMark: Node | Mark,
+  extensionAttributes: ExtensionAttribute[],
+): Record<string, any> {
+  return extensionAttributes
+    .filter(attribute => attribute.type === nodeOrMark.type.name)
+    .filter(item => item.attribute.rendered)
+    .map(item => {
+      if (!item.attribute.renderHTML) {
+        return {
+          [item.name]: nodeOrMark.attrs[item.name],
+        }
+      }
+
+      return item.attribute.renderHTML(nodeOrMark.attrs) || {}
+    })
+    .reduce((attributes, attribute) => mergeAttributes(attributes, attribute), {})
+}

package/node_modules/@tiptap/core/src/helpers/getSchema.ts

@@ -0,0 +1,12 @@
+import type { Schema } from '@tiptap/pm/model'
+
+import type { Editor } from '../Editor.js'
+import type { Extensions } from '../types.js'
+import { getSchemaByResolvedExtensions } from './getSchemaByResolvedExtensions.js'
+import { resolveExtensions } from './resolveExtensions.js'
+
+export function getSchema(extensions: Extensions, editor?: Editor): Schema {
+  const resolvedExtensions = resolveExtensions(extensions)
+
+  return getSchemaByResolvedExtensions(resolvedExtensions, editor)
+}