@tiptap/core 2.0.0-beta.17 → 2.0.0-beta.170

package/src/helpers/getDebugJSON.ts

@@ -0,0 +1,53 @@
+import { Node as ProseMirrorNode } from 'prosemirror-model'
+import { JSONContent } from '../types'
+
+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/src/helpers/getExtensionField.ts

@@ -0,0 +1,25 @@
+import { AnyExtension, RemoveThis, MaybeThisParameterType } from '../types'
+
+export function getExtensionField<T = any>(
+  extension: AnyExtension,
+  field: string,
+  context?: Omit<MaybeThisParameterType<T>, 'parent'>,
+): RemoveThis<T> {
+
+  if (extension.config[field] === undefined && extension.parent) {
+    return getExtensionField(extension.parent, field, context)
+  }
+
+  if (typeof extension.config[field] === 'function') {
+    const value = extension.config[field].bind({
+      ...context,
+      parent: extension.parent
+        ? getExtensionField(extension.parent, field, context)
+        : null,
+    })
+
+    return value
+  }
+
+  return extension.config[field]
+}

package/src/helpers/getHTMLFromFragment.ts

@@ -1,13 +1,14 @@
-import { Node, DOMSerializer, Schema } from 'prosemirror-model'
+import { DOMSerializer, Schema, Fragment } from 'prosemirror-model'
 
-export default function getHTMLFromFragment(doc: Node, schema: Schema): string {
-  const fragment = DOMSerializer
+export function getHTMLFromFragment(fragment: Fragment, schema: Schema): string {
+  const documentFragment = DOMSerializer
     .fromSchema(schema)
-    .serializeFragment(doc.content)
+    .serializeFragment(fragment)
 
   const temporaryDocument = document.implementation.createHTMLDocument()
   const container = temporaryDocument.createElement('div')
-  container.appendChild(fragment)
+
+  container.appendChild(documentFragment)
 
   return container.innerHTML
 }

package/src/helpers/getMarkAttributes.ts

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

package/src/helpers/getMarkRange.ts

@@ -1,7 +1,30 @@
-import { MarkType, ResolvedPos } from 'prosemirror-model'
+import { Mark as ProseMirrorMark, MarkType, ResolvedPos } from 'prosemirror-model'
+import { objectIncludes } from '../utilities/objectIncludes'
 import { Range } from '../types'
 
-export default function getMarkRange($pos: ResolvedPos, type: MarkType): Range | void {
+function findMarkInSet(
+  marks: ProseMirrorMark[],
+  type: MarkType,
+  attributes: Record<string, any> = {},
+): ProseMirrorMark | undefined {
+  return marks.find(item => {
+    return item.type === type && objectIncludes(item.attrs, attributes)
+  })
+}
+
+function isMarkInSet(
+  marks: ProseMirrorMark[],
+  type: MarkType,
+  attributes: Record<string, any> = {},
+): boolean {
+  return !!findMarkInSet(marks, type, attributes)
+}
+
+export function getMarkRange(
+  $pos: ResolvedPos,
+  type: MarkType,
+  attributes: Record<string, any> = {},
+): Range | void {
   if (!$pos || !type) {
     return
   }
@@ -12,9 +35,9 @@ export default function getMarkRange($pos: ResolvedPos, type: MarkType): Range |
     return
   }
 
-  const link = start.node.marks.find(mark => mark.type === type)
+  const mark = findMarkInSet(start.node.marks, type, attributes)
 
-  if (!link) {
+  if (!mark) {
     return
   }
 
@@ -23,12 +46,17 @@ export default function getMarkRange($pos: ResolvedPos, type: MarkType): Range |
   let endIndex = startIndex + 1
   let endPos = startPos + start.node.nodeSize
 
-  while (startIndex > 0 && link.isInSet($pos.parent.child(startIndex - 1).marks)) {
+  findMarkInSet(start.node.marks, type, attributes)
+
+  while (startIndex > 0 && mark.isInSet($pos.parent.child(startIndex - 1).marks)) {
     startIndex -= 1
     startPos -= $pos.parent.child(startIndex).nodeSize
   }
 
-  while (endIndex < $pos.parent.childCount && link.isInSet($pos.parent.child(endIndex).marks)) {
+  while (
+    endIndex < $pos.parent.childCount
+    && isMarkInSet($pos.parent.child(endIndex).marks, type, attributes)
+  ) {
     endPos += $pos.parent.child(endIndex).nodeSize
     endIndex += 1
   }

package/src/helpers/getMarkType.ts

@@ -1,7 +1,11 @@
 import { MarkType, Schema } from 'prosemirror-model'
 
-export default function getMarkType(nameOrType: string | MarkType, schema: Schema): MarkType {
+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]
   }
 

package/src/helpers/getMarksBetween.ts

@@ -1,16 +1,37 @@
-import { EditorState } from 'prosemirror-state'
+import { Node as ProseMirrorNode } from 'prosemirror-model'
 import { MarkRange } from '../types'
+import { getMarkRange } from './getMarkRange'
 
-export default function getMarksBetween(from: number, to: number, state: EditorState): MarkRange[] {
-  let marks: MarkRange[] = []
+export function getMarksBetween(from: number, to: number, doc: ProseMirrorNode): MarkRange[] {
+  const marks: MarkRange[] = []
 
-  state.doc.nodesBetween(from, to, (node, pos) => {
-    marks = [...marks, ...node.marks.map(mark => ({
-      from: pos,
-      to: pos + node.nodeSize,
-      mark,
-    }))]
-  })
+  // get all inclusive marks on empty selection
+  if (from === to) {
+    doc
+      .resolve(from)
+      .marks()
+      .forEach(mark => {
+        const $pos = doc.resolve(from - 1)
+        const range = getMarkRange($pos, mark.type)
+
+        if (!range) {
+          return
+        }
+
+        marks.push({
+          mark,
+          ...range,
+        })
+      })
+  } else {
+    doc.nodesBetween(from, to, (node, pos) => {
+      marks.push(...node.marks.map(mark => ({
+        from: pos,
+        to: pos + node.nodeSize,
+        mark,
+      })))
+    })
+  }
 
   return marks
 }

package/src/helpers/getNodeAttributes.ts

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

package/src/helpers/getNodeType.ts

@@ -1,7 +1,11 @@
 import { NodeType, Schema } from 'prosemirror-model'
 
-export default function getNodeType(nameOrType: string | NodeType, schema: Schema): NodeType {
+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]
   }
 

package/src/helpers/getRenderedAttributes.ts

@@ -1,8 +1,8 @@
 import { Node, Mark } from 'prosemirror-model'
-import { ExtensionAttribute, AnyObject } from '../types'
-import mergeAttributes from '../utilities/mergeAttributes'
+import { ExtensionAttribute } from '../types'
+import { mergeAttributes } from '../utilities/mergeAttributes'
 
-export default function getRenderedAttributes(nodeOrMark: Node | Mark, extensionAttributes: ExtensionAttribute[]): AnyObject {
+export function getRenderedAttributes(nodeOrMark: Node | Mark, extensionAttributes: ExtensionAttribute[]): Record<string, any> {
   return extensionAttributes
     .filter(item => item.attribute.rendered)
     .map(item => {
@@ -14,7 +14,5 @@ export default function getRenderedAttributes(nodeOrMark: Node | Mark, extension
 
       return item.attribute.renderHTML(nodeOrMark.attrs) || {}
     })
-    .reduce((attributes, attribute) => {
-      return mergeAttributes(attributes, attribute)
-    }, {})
+    .reduce((attributes, attribute) => mergeAttributes(attributes, attribute), {})
 }

package/src/helpers/getSchema.ts

@@ -1,137 +1,10 @@
-import { NodeSpec, MarkSpec, Schema } from 'prosemirror-model'
+import { Schema } from 'prosemirror-model'
+import { getSchemaByResolvedExtensions } from './getSchemaByResolvedExtensions'
+import { ExtensionManager } from '../ExtensionManager'
 import { Extensions } from '../types'
-import { ExtensionConfig, NodeConfig, MarkConfig } from '..'
-import splitExtensions from './splitExtensions'
-import getAttributesFromExtensions from './getAttributesFromExtensions'
-import getRenderedAttributes from './getRenderedAttributes'
-import isEmptyObject from '../utilities/isEmptyObject'
-import injectExtensionAttributesToParseRule from './injectExtensionAttributesToParseRule'
-import callOrReturn from '../utilities/callOrReturn'
 
-function cleanUpSchemaItem<T>(data: T) {
-  return Object.fromEntries(Object.entries(data).filter(([key, value]) => {
-    if (key === 'attrs' && isEmptyObject(value)) {
-      return false
-    }
+export function getSchema(extensions: Extensions): Schema {
+  const resolvedExtensions = ExtensionManager.resolve(extensions)
 
-    return value !== null && value !== undefined
-  })) as T
-}
-
-export default function getSchema(extensions: Extensions): Schema {
-  const allAttributes = getAttributesFromExtensions(extensions)
-  const { nodeExtensions, markExtensions } = splitExtensions(extensions)
-  const topNode = nodeExtensions.find(extension => extension.config.topNode)?.config.name
-  const nodeSchemaExtenders: (
-    | ExtensionConfig['extendNodeSchema']
-    | NodeConfig['extendNodeSchema']
-    | MarkConfig['extendNodeSchema']
-  )[] = []
-  const markSchemaExtenders: (
-    | ExtensionConfig['extendNodeSchema']
-    | NodeConfig['extendNodeSchema']
-    | MarkConfig['extendNodeSchema']
-  )[] = []
-
-  extensions.forEach(extension => {
-    if (typeof extension.config.extendNodeSchema === 'function') {
-      nodeSchemaExtenders.push(extension.config.extendNodeSchema)
-    }
-
-    if (typeof extension.config.extendMarkSchema === 'function') {
-      markSchemaExtenders.push(extension.config.extendMarkSchema)
-    }
-  })
-
-  const nodes = Object.fromEntries(nodeExtensions.map(extension => {
-    const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.config.name)
-    const context = { options: extension.options }
-
-    const extraNodeFields = nodeSchemaExtenders.reduce((fields, nodeSchemaExtender) => {
-      const extraFields = callOrReturn(nodeSchemaExtender, context, extension)
-
-      return {
-        ...fields,
-        ...extraFields,
-      }
-    }, {})
-
-    const schema: NodeSpec = cleanUpSchemaItem({
-      ...extraNodeFields,
-      content: callOrReturn(extension.config.content, context),
-      marks: callOrReturn(extension.config.marks, context),
-      group: callOrReturn(extension.config.group, context),
-      inline: callOrReturn(extension.config.inline, context),
-      atom: callOrReturn(extension.config.atom, context),
-      selectable: callOrReturn(extension.config.selectable, context),
-      draggable: callOrReturn(extension.config.draggable, context),
-      code: callOrReturn(extension.config.code, context),
-      defining: callOrReturn(extension.config.defining, context),
-      isolating: callOrReturn(extension.config.isolating, context),
-      attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
-        return [extensionAttribute.name, { default: extensionAttribute?.attribute?.default }]
-      })),
-    })
-
-    if (extension.config.parseHTML) {
-      schema.parseDOM = extension.config.parseHTML
-        .bind(context)()
-        ?.map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes))
-    }
-
-    if (extension.config.renderHTML) {
-      schema.toDOM = node => (extension.config.renderHTML as Function)?.bind(context)({
-        node,
-        HTMLAttributes: getRenderedAttributes(node, extensionAttributes),
-      })
-    }
-
-    return [extension.config.name, schema]
-  }))
-
-  const marks = Object.fromEntries(markExtensions.map(extension => {
-    const extensionAttributes = allAttributes.filter(attribute => attribute.type === extension.config.name)
-    const context = { options: extension.options }
-
-    const extraMarkFields = markSchemaExtenders.reduce((fields, markSchemaExtender) => {
-      const extraFields = callOrReturn(markSchemaExtender, context, extension)
-
-      return {
-        ...fields,
-        ...extraFields,
-      }
-    }, {})
-
-    const schema: MarkSpec = cleanUpSchemaItem({
-      ...extraMarkFields,
-      inclusive: callOrReturn(extension.config.inclusive, context),
-      excludes: callOrReturn(extension.config.excludes, context),
-      group: callOrReturn(extension.config.group, context),
-      spanning: callOrReturn(extension.config.spanning, context),
-      attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
-        return [extensionAttribute.name, { default: extensionAttribute?.attribute?.default }]
-      })),
-    })
-
-    if (extension.config.parseHTML) {
-      schema.parseDOM = extension.config.parseHTML
-        .bind(context)()
-        ?.map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes))
-    }
-
-    if (extension.config.renderHTML) {
-      schema.toDOM = mark => (extension.config.renderHTML as Function)?.bind(context)({
-        mark,
-        HTMLAttributes: getRenderedAttributes(mark, extensionAttributes),
-      })
-    }
-
-    return [extension.config.name, schema]
-  }))
-
-  return new Schema({
-    topNode,
-    nodes,
-    marks,
-  })
+  return getSchemaByResolvedExtensions(resolvedExtensions)
 }

package/src/helpers/getSchemaByResolvedExtensions.ts

@@ -0,0 +1,147 @@
+import { NodeSpec, MarkSpec, Schema } from 'prosemirror-model'
+import { AnyConfig, Extensions } from '../types'
+import { NodeConfig, MarkConfig } from '..'
+import { splitExtensions } from './splitExtensions'
+import { getAttributesFromExtensions } from './getAttributesFromExtensions'
+import { getRenderedAttributes } from './getRenderedAttributes'
+import { isEmptyObject } from '../utilities/isEmptyObject'
+import { injectExtensionAttributesToParseRule } from './injectExtensionAttributesToParseRule'
+import { callOrReturn } from '../utilities/callOrReturn'
+import { getExtensionField } from './getExtensionField'
+
+function cleanUpSchemaItem<T>(data: T) {
+  return Object.fromEntries(Object.entries(data).filter(([key, value]) => {
+    if (key === 'attrs' && isEmptyObject(value)) {
+      return false
+    }
+
+    return value !== null && value !== undefined
+  })) as T
+}
+
+export function getSchemaByResolvedExtensions(extensions: Extensions): 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,
+    }
+
+    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)),
+      defining: callOrReturn(getExtensionField<NodeConfig['defining']>(extension, 'defining', context)),
+      isolating: callOrReturn(getExtensionField<NodeConfig['isolating']>(extension, 'isolating', context)),
+      attrs: Object.fromEntries(extensionAttributes.map(extensionAttribute => {
+        return [extensionAttribute.name, { default: extensionAttribute?.attribute?.default }]
+      })),
+    })
+
+    const parseHTML = callOrReturn(getExtensionField<NodeConfig['parseHTML']>(extension, 'parseHTML', context))
+
+    if (parseHTML) {
+      schema.parseDOM = parseHTML
+        .map(parseRule => injectExtensionAttributesToParseRule(parseRule, extensionAttributes))
+    }
+
+    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,
+    }
+
+    const extraMarkFields = extensions.reduce((fields, e) => {
+      const extendMarkSchema = getExtensionField<AnyConfig['extendMarkSchema']>(
+        e,
+        'extendMarkSchema',
+        context,
+      )
+
+      return {
+        ...fields,
+        ...(extendMarkSchema ? extendMarkSchema(extension) : {}),
+      }
+    }, {})
+
+    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(extensionAttribute => {
+        return [extensionAttribute.name, { default: extensionAttribute?.attribute?.default }]
+      })),
+    })
+
+    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/src/helpers/getSchemaTypeByName.ts

@@ -1,13 +1,5 @@
 import { MarkType, NodeType, Schema } from 'prosemirror-model'
 
-export default function getSchemaTypeByName(name: string, schema: Schema): NodeType | MarkType | null {
-  if (schema.nodes[name]) {
-    return schema.nodes[name]
-  }
-
-  if (schema.marks[name]) {
-    return schema.marks[name]
-  }
-
-  return null
+export function getSchemaTypeByName(name: string, schema: Schema): NodeType | MarkType | null {
+  return schema.nodes[name] || schema.marks[name] || null
 }

package/src/helpers/getSchemaTypeNameByName.ts

@@ -1,6 +1,6 @@
 import { Schema } from 'prosemirror-model'
 
-export default function getSchemaTypeNameByName(name: string, schema: Schema): 'node' | 'mark' | null {
+export function getSchemaTypeNameByName(name: string, schema: Schema): 'node' | 'mark' | null {
   if (schema.nodes[name]) {
     return 'node'
   }

package/src/helpers/getSplittedAttributes.ts

@@ -1,10 +1,10 @@
-import { AnyObject, ExtensionAttribute } from '../types'
+import { ExtensionAttribute } from '../types'
 
-export default function getSplittedAttributes(
+export function getSplittedAttributes(
   extensionAttributes: ExtensionAttribute[],
   typeName: string,
-  attributes: AnyObject,
-): AnyObject {
+  attributes: Record<string, any>,
+): Record<string, any> {
   return Object.fromEntries(Object
     .entries(attributes)
     .filter(([name]) => {