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

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

@@ -0,0 +1,183 @@
+import type { MarkSpec, NodeSpec, TagParseRule } from '@tiptap/pm/model'
+import { Schema } from '@tiptap/pm/model'
+
+import type { Editor, MarkConfig, NodeConfig } from '../index.js'
+import type { AnyConfig, Extensions } from '../types.js'
+import { callOrReturn } from '../utilities/callOrReturn.js'
+import { isEmptyObject } from '../utilities/isEmptyObject.js'
+import { getAttributesFromExtensions } from './getAttributesFromExtensions.js'
+import { getExtensionField } from './getExtensionField.js'
+import { getRenderedAttributes } from './getRenderedAttributes.js'
+import { injectExtensionAttributesToParseRule } from './injectExtensionAttributesToParseRule.js'
+import { splitExtensions } from './splitExtensions.js'
+
+function cleanUpSchemaItem<T>(data: T) {
+  return Object.fromEntries(
+    // @ts-ignore
+    Object.entries(data).filter(([key, value]) => {
+      if (key === 'attrs' && isEmptyObject(value as object | undefined)) {
+        return false
+      }
+
+      return value !== null && value !== undefined
+    }),
+  ) as T
+}
+
+/**
+ * Builds an attribute spec tuple for ProseMirror schema from an extension attribute.
+ * @param extensionAttribute The extension attribute to build the spec for
+ * @returns A tuple of [attributeName, spec]
+ */
+function buildAttributeSpec(
+  extensionAttribute: ReturnType<typeof getAttributesFromExtensions>[number],
+): [string, Record<string, any>] {
+  const spec: Record<string, any> = {}
+
+  // Only include 'default' if the attribute is not required and default is set on the attribute
+  if (!extensionAttribute?.attribute?.isRequired && 'default' in (extensionAttribute?.attribute || {})) {
+    spec.default = extensionAttribute.attribute.default
+  }
+
+  // Only include 'validate' if it's defined
+  if (extensionAttribute?.attribute?.validate !== undefined) {
+    spec.validate = extensionAttribute.attribute.validate
+  }
+
+  return [extensionAttribute.name, spec]
+}
+
+/**
+ * Creates a new Prosemirror schema based on the given extensions.
+ * @param extensions An array of Tiptap extensions
+ * @param editor The editor instance
+ * @returns A Prosemirror schema
+ */
+export function getSchemaByResolvedExtensions(extensions: Extensions, editor?: Editor): Schema {
+  const allAttributes = getAttributesFromExtensions(extensions)
+  const { nodeExtensions, markExtensions } = splitExtensions(extensions)
+  const topNode = nodeExtensions.find(extension => getExtensionField(extension, 'topNode'))?.name
+
+  const nodes = Object.fromEntries(
+    nodeExtensions.map(extension => {
+      const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name)
+      const context = {
+        name: extension.name,
+        options: extension.options,
+        storage: extension.storage,
+        editor,
+      }
+
+      const extraNodeFields = extensions.reduce((fields, e) => {
+        const extendNodeSchema = getExtensionField<AnyConfig['extendNodeSchema']>(e, 'extendNodeSchema', context)
+
+        return {
+          ...fields,
+          ...(extendNodeSchema ? extendNodeSchema(extension) : {}),
+        }
+      }, {})
+
+      const schema: NodeSpec = cleanUpSchemaItem({
+        ...extraNodeFields,
+        content: callOrReturn(getExtensionField<NodeConfig['content']>(extension, 'content', context)),
+        marks: callOrReturn(getExtensionField<NodeConfig['marks']>(extension, 'marks', context)),
+        group: callOrReturn(getExtensionField<NodeConfig['group']>(extension, 'group', context)),
+        inline: callOrReturn(getExtensionField<NodeConfig['inline']>(extension, 'inline', context)),
+        atom: callOrReturn(getExtensionField<NodeConfig['atom']>(extension, 'atom', context)),
+        selectable: callOrReturn(getExtensionField<NodeConfig['selectable']>(extension, 'selectable', context)),
+        draggable: callOrReturn(getExtensionField<NodeConfig['draggable']>(extension, 'draggable', context)),
+        code: callOrReturn(getExtensionField<NodeConfig['code']>(extension, 'code', context)),
+        whitespace: callOrReturn(getExtensionField<NodeConfig['whitespace']>(extension, 'whitespace', context)),
+        linebreakReplacement: callOrReturn(
+          getExtensionField<NodeConfig['linebreakReplacement']>(extension, 'linebreakReplacement', context),
+        ),
+        defining: callOrReturn(getExtensionField<NodeConfig['defining']>(extension, 'defining', context)),
+        isolating: callOrReturn(getExtensionField<NodeConfig['isolating']>(extension, 'isolating', context)),
+        attrs: Object.fromEntries(extensionAttributes.map(buildAttributeSpec)),
+      })
+
+      const parseHTML = callOrReturn(getExtensionField<NodeConfig['parseHTML']>(extension, 'parseHTML', context))
+
+      if (parseHTML) {
+        schema.parseDOM = parseHTML.map(parseRule =>
+          injectExtensionAttributesToParseRule(parseRule, extensionAttributes),
+        ) as TagParseRule[]
+      }
+
+      const renderHTML = getExtensionField<NodeConfig['renderHTML']>(extension, 'renderHTML', context)
+
+      if (renderHTML) {
+        schema.toDOM = node =>
+          renderHTML({
+            node,
+            HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
+          })
+      }
+
+      const renderText = getExtensionField<NodeConfig['renderText']>(extension, 'renderText', context)
+
+      if (renderText) {
+        schema.toText = renderText
+      }
+
+      return [extension.name, schema]
+    }),
+  )
+
+  const marks = Object.fromEntries(
+    markExtensions.map(extension => {
+      const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.name)
+      const context = {
+        name: extension.name,
+        options: extension.options,
+        storage: extension.storage,
+        editor,
+      }
+
+      const extraMarkFields = extensions.reduce((fields, e) => {
+        const extendMarkSchema = getExtensionField<AnyConfig['extendMarkSchema']>(e, 'extendMarkSchema', context)
+
+        return {
+          ...fields,
+          ...(extendMarkSchema ? extendMarkSchema(extension as any) : {}),
+        }
+      }, {})
+
+      const schema: MarkSpec = cleanUpSchemaItem({
+        ...extraMarkFields,
+        inclusive: callOrReturn(getExtensionField<MarkConfig['inclusive']>(extension, 'inclusive', context)),
+        excludes: callOrReturn(getExtensionField<MarkConfig['excludes']>(extension, 'excludes', context)),
+        group: callOrReturn(getExtensionField<MarkConfig['group']>(extension, 'group', context)),
+        spanning: callOrReturn(getExtensionField<MarkConfig['spanning']>(extension, 'spanning', context)),
+        code: callOrReturn(getExtensionField<MarkConfig['code']>(extension, 'code', context)),
+        attrs: Object.fromEntries(extensionAttributes.map(buildAttributeSpec)),
+      })
+
+      const parseHTML = callOrReturn(getExtensionField<MarkConfig['parseHTML']>(extension, 'parseHTML', context))
+
+      if (parseHTML) {
+        schema.parseDOM = parseHTML.map(parseRule =>
+          injectExtensionAttributesToParseRule(parseRule, extensionAttributes),
+        )
+      }
+
+      const renderHTML = getExtensionField<MarkConfig['renderHTML']>(extension, 'renderHTML', context)
+
+      if (renderHTML) {
+        schema.toDOM = mark =>
+          renderHTML({
+            mark,
+            HTMLAttributes: getRenderedAttributes(mark, extensionAttributes),
+          })
+      }
+
+      return [extension.name, schema]
+    }),
+  )
+
+  return new Schema({
+    topNode,
+    nodes,
+    marks,
+  })
+}

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

@@ -0,0 +1,11 @@
+import type { MarkType, NodeType, Schema } from '@tiptap/pm/model'
+
+/**
+ * Tries to get a node or mark type by its name.
+ * @param name The name of the node or mark type
+ * @param schema The Prosemiror schema to search in
+ * @returns The node or mark type, or null if it doesn't exist
+ */
+export function getSchemaTypeByName(name: string, schema: Schema): NodeType | MarkType | null {
+  return schema.nodes[name] || schema.marks[name] || null
+}

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

@@ -0,0 +1,19 @@
+import type { Schema } from '@tiptap/pm/model'
+
+/**
+ * Get the type of a schema item by its name.
+ * @param name The name of the schema item
+ * @param schema The Prosemiror schema to search in
+ * @returns The type of the schema item (`node` or `mark`), or null if it doesn't exist
+ */
+export function getSchemaTypeNameByName(name: string, schema: Schema): 'node' | 'mark' | null {
+  if (schema.nodes[name]) {
+    return 'node'
+  }
+
+  if (schema.marks[name]) {
+    return 'mark'
+  }
+
+  return null
+}

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

@@ -0,0 +1,28 @@
+import type { ExtensionAttribute } from '../types.js'
+
+/**
+ * Return attributes of an extension that should be splitted by keepOnSplit flag
+ * @param extensionAttributes Array of extension attributes
+ * @param typeName The type of the extension
+ * @param attributes The attributes of the extension
+ * @returns The splitted attributes
+ */
+export function getSplittedAttributes(
+  extensionAttributes: ExtensionAttribute[],
+  typeName: string,
+  attributes: Record<string, any>,
+): Record<string, any> {
+  return Object.fromEntries(
+    Object.entries(attributes).filter(([name]) => {
+      const extensionAttribute = extensionAttributes.find(item => {
+        return item.type === typeName && item.name === name
+      })
+
+      if (!extensionAttribute) {
+        return false
+      }
+
+      return extensionAttribute.attribute.keepOnSplit
+    }),
+  )
+}

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

@@ -0,0 +1,28 @@
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
+
+import type { TextSerializer } from '../types.js'
+import { getTextBetween } from './getTextBetween.js'
+
+/**
+ * Gets the text of a Prosemirror node
+ * @param node The Prosemirror node
+ * @param options Options for the text serializer & block separator
+ * @returns The text of the node
+ * @example ```js
+ * const text = getText(node, { blockSeparator: '\n' })
+ * ```
+ */
+export function getText(
+  node: ProseMirrorNode,
+  options?: {
+    blockSeparator?: string
+    textSerializers?: Record<string, TextSerializer>
+  },
+) {
+  const range = {
+    from: 0,
+    to: node.content.size,
+  }
+
+  return getTextBetween(node, range, options)
+}

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

@@ -0,0 +1,52 @@
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
+
+import type { Range, TextSerializer } from '../types.js'
+
+/**
+ * Gets the text between two positions in a Prosemirror node
+ * and serializes it using the given text serializers and block separator (see getText)
+ * @param startNode The Prosemirror node to start from
+ * @param range The range of the text to get
+ * @param options Options for the text serializer & block separator
+ * @returns The text between the two positions
+ */
+export function getTextBetween(
+  startNode: ProseMirrorNode,
+  range: Range,
+  options?: {
+    blockSeparator?: string
+    textSerializers?: Record<string, TextSerializer>
+  },
+): string {
+  const { from, to } = range
+  const { blockSeparator = '\n\n', textSerializers = {} } = options || {}
+  let text = ''
+
+  startNode.nodesBetween(from, to, (node, pos, parent, index) => {
+    if (node.isBlock && pos > from) {
+      text += blockSeparator
+    }
+
+    const textSerializer = textSerializers?.[node.type.name]
+
+    if (textSerializer) {
+      if (parent) {
+        text += textSerializer({
+          node,
+          pos,
+          parent,
+          index,
+          range,
+        })
+      }
+      // do not descend into child nodes when there exists a serializer
+      return false
+    }
+
+    if (node.isText) {
+      text += node?.text?.slice(Math.max(from, pos) - pos, to - pos) // eslint-disable-line
+    }
+  })
+
+  return text
+}

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

@@ -0,0 +1,29 @@
+import type { ResolvedPos } from '@tiptap/pm/model'
+
+/**
+ * Returns the text content of a resolved prosemirror position
+ * @param $from The resolved position to get the text content from
+ * @param maxMatch The maximum number of characters to match
+ * @returns The text content
+ */
+export const getTextContentFromNodes = ($from: ResolvedPos, maxMatch = 500) => {
+  let textBefore = ''
+
+  const sliceEndPos = $from.parentOffset
+
+  $from.parent.nodesBetween(Math.max(0, sliceEndPos - maxMatch), sliceEndPos, (node, pos, parent, index) => {
+    const chunk =
+      node.type.spec.toText?.({
+        node,
+        pos,
+        parent,
+        index,
+      }) ||
+      node.textContent ||
+      '%leaf%'
+
+    textBefore += node.isAtom && !node.isText ? chunk : chunk.slice(0, Math.max(0, sliceEndPos - pos))
+  })
+
+  return textBefore
+}

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

@@ -0,0 +1,16 @@
+import type { Schema } from '@tiptap/pm/model'
+
+import type { TextSerializer } from '../types.js'
+
+/**
+ * Find text serializers `toText` in a Prosemirror schema
+ * @param schema The Prosemirror schema to search in
+ * @returns A record of text serializers by node name
+ */
+export function getTextSerializersFromSchema(schema: Schema): Record<string, TextSerializer> {
+  return Object.fromEntries(
+    Object.entries(schema.nodes)
+      .filter(([, node]) => node.spec.toText)
+      .map(([name, node]) => [name, node.spec.toText]),
+  )
+}

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

@@ -0,0 +1,55 @@
+export * from './combineTransactionSteps.js'
+export * from './createChainableState.js'
+export * from './createDocument.js'
+export * from './createNodeFromContent.js'
+export * from './defaultBlockAt.js'
+export * from './findChildren.js'
+export * from './findChildrenInRange.js'
+export * from './findParentNode.js'
+export * from './findParentNodeClosestToPos.js'
+export * from './flattenExtensions.js'
+export * from './generateHTML.js'
+export * from './generateJSON.js'
+export * from './generateText.js'
+export * from './getAttributes.js'
+export * from './getAttributesFromExtensions.js'
+export * from './getChangedRanges.js'
+export * from './getDebugJSON.js'
+export * from './getExtensionField.js'
+export * from './getHTMLFromFragment.js'
+export * from './getMarkAttributes.js'
+export * from './getMarkRange.js'
+export * from './getMarksBetween.js'
+export * from './getMarkType.js'
+export * from './getNodeAtPosition.js'
+export * from './getNodeAttributes.js'
+export * from './getNodeType.js'
+export * from './getRenderedAttributes.js'
+export * from './getSchema.js'
+export * from './getSchemaByResolvedExtensions.js'
+export * from './getSchemaTypeByName.js'
+export * from './getSchemaTypeNameByName.js'
+export * from './getSplittedAttributes.js'
+export * from './getText.js'
+export * from './getTextBetween.js'
+export * from './getTextContentFromNodes.js'
+export * from './getTextSerializersFromSchema.js'
+export * from './injectExtensionAttributesToParseRule.js'
+export * from './isActive.js'
+export * from './isAtEndOfNode.js'
+export * from './isAtStartOfNode.js'
+export * from './isExtensionRulesEnabled.js'
+export * from './isList.js'
+export * from './isMarkActive.js'
+export * from './isNodeActive.js'
+export * from './isNodeEmpty.js'
+export * from './isNodeSelection.js'
+export * from './isTextSelection.js'
+export * from './MappablePosition.js'
+export * from './posToDOMRect.js'
+export * from './resolveExtensions.js'
+export * from './resolveFocusPosition.js'
+export * from './rewriteUnknownContent.js'
+export * from './selectionToInsertionEnd.js'
+export * from './sortExtensions.js'
+export * from './splitExtensions.js'

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

@@ -0,0 +1,47 @@
+import type { ParseRule } from '@tiptap/pm/model'
+
+import type { ExtensionAttribute } from '../types.js'
+import { fromString } from '../utilities/fromString.js'
+
+/**
+ * This function merges extension attributes into parserule attributes (`attrs` or `getAttrs`).
+ * Cancels when `getAttrs` returned `false`.
+ * @param parseRule ProseMirror ParseRule
+ * @param extensionAttributes List of attributes to inject
+ */
+export function injectExtensionAttributesToParseRule(
+  parseRule: ParseRule,
+  extensionAttributes: ExtensionAttribute[],
+): ParseRule {
+  if ('style' in parseRule) {
+    return parseRule
+  }
+
+  return {
+    ...parseRule,
+    getAttrs: (node: HTMLElement) => {
+      const oldAttributes = parseRule.getAttrs ? parseRule.getAttrs(node) : parseRule.attrs
+
+      if (oldAttributes === false) {
+        return false
+      }
+
+      const newAttributes = extensionAttributes.reduce((items, item) => {
+        const value = item.attribute.parseHTML
+          ? item.attribute.parseHTML(node)
+          : fromString(node.getAttribute(item.name))
+
+        if (value === null || value === undefined) {
+          return items
+        }
+
+        return {
+          ...items,
+          [item.name]: value,
+        }
+      }, {})
+
+      return { ...oldAttributes, ...newAttributes }
+    },
+  }
+}

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

@@ -0,0 +1,23 @@
+import type { EditorState } from '@tiptap/pm/state'
+
+import { getSchemaTypeNameByName } from './getSchemaTypeNameByName.js'
+import { isMarkActive } from './isMarkActive.js'
+import { isNodeActive } from './isNodeActive.js'
+
+export function isActive(state: EditorState, name: string | null, attributes: Record<string, any> = {}): boolean {
+  if (!name) {
+    return isNodeActive(state, null, attributes) || isMarkActive(state, null, attributes)
+  }
+
+  const schemaType = getSchemaTypeNameByName(name, state.schema)
+
+  if (schemaType === 'node') {
+    return isNodeActive(state, name, attributes)
+  }
+
+  if (schemaType === 'mark') {
+    return isMarkActive(state, name, attributes)
+  }
+
+  return false
+}

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

@@ -0,0 +1,29 @@
+import type { EditorState } from '@tiptap/pm/state'
+
+import { findParentNode } from './findParentNode.js'
+
+export const isAtEndOfNode = (state: EditorState, nodeType?: string) => {
+  const { $from, $to, $anchor } = state.selection
+
+  if (nodeType) {
+    const parentNode = findParentNode(node => node.type.name === nodeType)(state.selection)
+
+    if (!parentNode) {
+      return false
+    }
+
+    const $parentPos = state.doc.resolve(parentNode.pos + 1)
+
+    if ($anchor.pos + 1 === $parentPos.end()) {
+      return true
+    }
+
+    return false
+  }
+
+  if ($to.parentOffset < $to.parent.nodeSize - 2 || $from.pos !== $to.pos) {
+    return false
+  }
+
+  return true
+}

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

@@ -0,0 +1,11 @@
+import type { EditorState } from '@tiptap/pm/state'
+
+export const isAtStartOfNode = (state: EditorState) => {
+  const { $from, $to } = state.selection
+
+  if ($from.parentOffset > 0 || $from.pos !== $to.pos) {
+    return false
+  }
+
+  return true
+}

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

@@ -0,0 +1,13 @@
+import type { AnyExtension, EnableRules } from '../types.js'
+
+export function isExtensionRulesEnabled(extension: AnyExtension, enabled: EnableRules): boolean {
+  if (Array.isArray(enabled)) {
+    return enabled.some(enabledExtension => {
+      const name = typeof enabledExtension === 'string' ? enabledExtension : enabledExtension.name
+
+      return name === extension.name
+    })
+  }
+
+  return enabled
+}

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

@@ -0,0 +1,27 @@
+import { getExtensionField } from '../helpers/getExtensionField.js'
+import type { NodeConfig } from '../index.js'
+import type { Extensions } from '../types.js'
+import { callOrReturn } from '../utilities/callOrReturn.js'
+import { splitExtensions } from './splitExtensions.js'
+
+export function isList(name: string, extensions: Extensions): boolean {
+  const { nodeExtensions } = splitExtensions(extensions)
+  const extension = nodeExtensions.find(item => item.name === name)
+
+  if (!extension) {
+    return false
+  }
+
+  const context = {
+    name: extension.name,
+    options: extension.options,
+    storage: extension.storage,
+  }
+  const group = callOrReturn(getExtensionField<NodeConfig['group']>(extension, 'group', context))
+
+  if (typeof group !== 'string') {
+    return false
+  }
+
+  return group.split(' ').includes('list')
+}

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

@@ -0,0 +1,94 @@
+import type { MarkType } from '@tiptap/pm/model'
+import type { EditorState } from '@tiptap/pm/state'
+
+import type { MarkRange } from '../types.js'
+import { objectIncludes } from '../utilities/objectIncludes.js'
+import { getMarkType } from './getMarkType.js'
+
+export function isMarkActive(
+  state: EditorState,
+  typeOrName: MarkType | string | null,
+  attributes: Record<string, any> = {},
+): boolean {
+  const { empty, ranges } = state.selection
+  const type = typeOrName ? getMarkType(typeOrName, state.schema) : null
+
+  if (empty) {
+    return !!(state.storedMarks || state.selection.$from.marks())
+      .filter(mark => {
+        if (!type) {
+          return true
+        }
+
+        return type.name === mark.type.name
+      })
+      .find(mark => objectIncludes(mark.attrs, attributes, { strict: false }))
+  }
+
+  let selectionRange = 0
+  const markRanges: MarkRange[] = []
+
+  ranges.forEach(({ $from, $to }) => {
+    const from = $from.pos
+    const to = $to.pos
+
+    state.doc.nodesBetween(from, to, (node, pos) => {
+      // ignore selected text inside nodes whose schema disallows this mark type
+      if (type && node.inlineContent && !node.type.allowsMarkType(type)) {
+        return false
+      }
+
+      if (!node.isText && !node.marks.length) {
+        return
+      }
+
+      const relativeFrom = Math.max(from, pos)
+      const relativeTo = Math.min(to, pos + node.nodeSize)
+      const range = relativeTo - relativeFrom
+
+      selectionRange += range
+
+      markRanges.push(
+        ...node.marks.map(mark => ({
+          mark,
+          from: relativeFrom,
+          to: relativeTo,
+        })),
+      )
+    })
+  })
+
+  if (selectionRange === 0) {
+    return false
+  }
+
+  // calculate range of matched mark
+  const matchedRange = markRanges
+    .filter(markRange => {
+      if (!type) {
+        return true
+      }
+
+      return type.name === markRange.mark.type.name
+    })
+    .filter(markRange => objectIncludes(markRange.mark.attrs, attributes, { strict: false }))
+    .reduce((sum, markRange) => sum + markRange.to - markRange.from, 0)
+
+  // calculate range of marks that excludes the searched mark
+  // for example `code` doesn’t allow any other marks
+  const excludedRange = markRanges
+    .filter(markRange => {
+      if (!type) {
+        return true
+      }
+
+      return markRange.mark.type !== type && markRange.mark.type.excludes(type)
+    })
+    .reduce((sum, markRange) => sum + markRange.to - markRange.from, 0)
+
+  // we only include the result of `excludedRange`
+  // if there is a match at all
+  const range = matchedRange > 0 ? matchedRange + excludedRange : matchedRange
+
+  return range >= selectionRange
+}