@jvs-milkdown/prose 1.0.0

package/src/toolkit/prose/node.ts

@@ -0,0 +1,63 @@
+import type { MarkType, Node, NodeType, ResolvedPos } from '../../model'
+import type { Predicate } from './types'
+
+export interface NodeWithPos {
+  pos: number
+  node: Node
+}
+export interface NodeWithFromTo {
+  from: number
+  to: number
+  node: Node
+}
+
+export function flatten(node: Node, descend = true): NodeWithPos[] {
+  const result: NodeWithPos[] = []
+  node.descendants((child, pos) => {
+    result.push({ node: child, pos })
+    if (!descend) return false
+
+    return undefined
+  })
+  return result
+}
+
+export function findChildren(predicate: Predicate) {
+  return (node: Node, descend?: boolean): NodeWithPos[] =>
+    flatten(node, descend).filter((child) => predicate(child.node))
+}
+
+export function findChildrenByMark(
+  node: Node,
+  markType: MarkType,
+  descend?: boolean
+): NodeWithPos[] {
+  return findChildren((child) => Boolean(markType.isInSet(child.marks)))(
+    node,
+    descend
+  )
+}
+
+export function findParent(predicate: Predicate) {
+  return ($pos: ResolvedPos): NodeWithFromTo | undefined => {
+    for (let depth = $pos.depth; depth > 0; depth -= 1) {
+      const node = $pos.node(depth)
+
+      if (predicate(node)) {
+        const from = $pos.before(depth)
+        const to = $pos.after(depth)
+        return {
+          from,
+          to,
+          node,
+        }
+      }
+    }
+
+    return undefined
+  }
+}
+
+export function findParentNodeType($pos: ResolvedPos, nodeType: NodeType) {
+  return findParent((node) => node.type === nodeType)($pos)
+}

package/src/toolkit/prose/schema.ts

@@ -0,0 +1,19 @@
+import { getAtomFromSchemaFail } from '@jvs-milkdown/exception'
+
+import type { MarkType, NodeType, Schema } from '../../model'
+
+export function getNodeFromSchema(type: string, schema: Schema): NodeType {
+  const target = schema.nodes[type]
+
+  if (!target) throw getAtomFromSchemaFail('node', type)
+
+  return target
+}
+
+export function getMarkFromSchema(type: string, schema: Schema): MarkType {
+  const target = schema.marks[type]
+
+  if (!target) throw getAtomFromSchemaFail('mark', type)
+
+  return target
+}

package/src/toolkit/prose/selection.ts

@@ -0,0 +1,97 @@
+import type { NodeType, Node as ProseNode, ResolvedPos } from '../../model'
+import type { EditorState, Selection } from '../../state'
+import type { Predicate } from './types'
+
+import { NodeSelection } from '../../state'
+import { equalNodeType } from './helper'
+
+export interface ContentNodeWithPos {
+  pos: number
+  start: number
+  depth: number
+  node: ProseNode
+}
+
+export function findParentNodeClosestToPos(predicate: Predicate) {
+  return ($pos: ResolvedPos): ContentNodeWithPos | undefined => {
+    for (let i = $pos.depth; i > 0; i--) {
+      const node = $pos.node(i)
+      if (predicate(node)) {
+        return {
+          pos: $pos.before(i),
+          start: $pos.start(i),
+          depth: i,
+          node,
+        }
+      }
+    }
+
+    return undefined
+  }
+}
+
+export function findParentNode(predicate: Predicate) {
+  return (selection: Selection): ContentNodeWithPos | undefined => {
+    return findParentNodeClosestToPos(predicate)(selection.$from)
+  }
+}
+
+export function findSelectedNodeOfType(
+  selection: Selection,
+  nodeType: NodeType
+): ContentNodeWithPos | undefined {
+  if (!(selection instanceof NodeSelection)) return
+
+  const { node, $from } = selection
+  if (equalNodeType(nodeType, node))
+    return {
+      node,
+      pos: $from.pos,
+      start: $from.start($from.depth),
+      depth: $from.depth,
+    }
+
+  return undefined
+}
+
+export type FindNodeInSelectionResult = {
+  hasNode: boolean
+  pos: number
+  target: ProseNode | null
+}
+
+export const findNodeInSelection = (
+  state: EditorState,
+  node: NodeType
+): FindNodeInSelectionResult => {
+  const { selection, doc } = state
+  if (selection instanceof NodeSelection) {
+    return {
+      hasNode: selection.node.type === node,
+      pos: selection.from,
+      target: selection.node,
+    }
+  }
+
+  const { from, to } = selection
+
+  let hasNode = false
+  let pos = -1
+  let target: ProseNode | null = null
+  doc.nodesBetween(from, to, (n, p) => {
+    if (target) return false
+    if (n.type === node) {
+      hasNode = true
+      pos = p
+      target = n
+      return false
+    }
+    return true
+  })
+
+  return {
+    hasNode,
+    pos,
+    target,
+  }
+}

package/src/toolkit/prose/types.ts

@@ -0,0 +1,3 @@
+import type { Node } from '../../model'
+
+export type Predicate = (node: Node) => boolean

package/src/transform.ts

@@ -0,0 +1 @@
+export * from 'prosemirror-transform'

package/src/view.ts

@@ -0,0 +1 @@
+export * from 'prosemirror-view'