@jvs-milkdown/transformer 1.0.0

package/src/serializer/state.ts

@@ -0,0 +1,355 @@
+import type {
+  Fragment,
+  MarkType,
+  Node,
+  NodeType,
+  Schema,
+} from '@jvs-milkdown/prose/model'
+
+import { serializerMatchError } from '@jvs-milkdown/exception'
+import { Mark } from '@jvs-milkdown/prose/model'
+
+import type {
+  JSONRecord,
+  MarkSchema,
+  MarkdownNode,
+  NodeSchema,
+  RemarkParser,
+  Root,
+} from '../utility'
+import type { Serializer } from './types'
+
+import { Stack } from '../utility'
+import { SerializerStackElement } from './stack-element'
+
+const isFragment = (x: Node | Fragment): x is Fragment =>
+  Object.prototype.hasOwnProperty.call(x, 'size')
+
+/// State for serializer.
+/// Transform prosemirror state into remark AST.
+export class SerializerState extends Stack<
+  MarkdownNode,
+  SerializerStackElement
+> {
+  /// @internal
+  #marks: readonly Mark[] = Mark.none
+  /// Get the schema of state.
+  readonly schema: Schema
+
+  /// Create a serializer from schema and remark instance.
+  ///
+  /// ```typescript
+  /// const serializer = SerializerState.create(schema, remark)
+  /// const markdown = parser(prosemirrorDoc)
+  /// ```
+  static create = (schema: Schema, remark: RemarkParser): Serializer => {
+    const state = new this(schema)
+    return (content: Node) => {
+      state.run(content)
+      return state.toString(remark)
+    }
+  }
+
+  /// @internal
+  constructor(schema: Schema) {
+    super()
+    this.schema = schema
+  }
+
+  /// @internal
+  #matchTarget = (node: Node | Mark): NodeType | MarkType => {
+    const result = Object.values({
+      ...this.schema.nodes,
+      ...this.schema.marks,
+    }).find((x): x is NodeType | MarkType => {
+      const spec = x.spec as NodeSchema | MarkSchema
+      return spec.toMarkdown.match(node as Node & Mark)
+    })
+
+    if (!result) throw serializerMatchError(node.type)
+
+    return result
+  }
+
+  /// @internal
+  #runProseNode = (node: Node) => {
+    const type = this.#matchTarget(node)
+    const spec = type.spec as NodeSchema
+    return spec.toMarkdown.runner(this, node)
+  }
+
+  /// @internal
+  #runProseMark = (mark: Mark, node: Node) => {
+    const type = this.#matchTarget(mark)
+    const spec = type.spec as MarkSchema
+    return spec.toMarkdown.runner(this, mark, node)
+  }
+
+  /// @internal
+  #runNode = (node: Node) => {
+    const { marks } = node
+    const getPriority = (x: Mark) => x.type.spec.priority ?? 50
+    const tmp = [...marks].sort((a, b) => getPriority(a) - getPriority(b))
+    const unPreventNext = tmp.every((mark) => !this.#runProseMark(mark, node))
+    if (unPreventNext) this.#runProseNode(node)
+
+    marks.forEach((mark) => this.#closeMark(mark))
+  }
+
+  /// @internal
+  #searchType = (child: MarkdownNode, type: string): MarkdownNode => {
+    if (child.type === type) return child
+
+    if (child.children?.length !== 1) return child
+
+    const searchNode = (node: MarkdownNode): MarkdownNode | null => {
+      if (node.type === type) return node.value != null ? null : node
+
+      if (node.children?.length !== 1) return null
+
+      const [firstChild] = node.children
+      if (!firstChild) return null
+
+      return searchNode(firstChild)
+    }
+
+    const target = searchNode(child)
+
+    if (!target) return child
+
+    const tmp = target.children ? [...target.children] : undefined
+    const node = { ...child, children: tmp }
+    node.children = tmp
+    target.children = [node]
+
+    return target
+  }
+
+  /// @internal
+  #maybeMergeChildren = (node: MarkdownNode): MarkdownNode => {
+    const { children } = node
+    if (!children) return node
+
+    node.children = children.reduce((nextChildren, child, index) => {
+      if (index === 0) return [child]
+
+      const last = nextChildren.at(-1)
+      if (last && last.isMark && child.isMark) {
+        child = this.#searchType(child, last.type)
+        const { children: currChildren, ...currRest } = child
+        const { children: prevChildren, ...prevRest } = last
+        if (
+          child.type === last.type &&
+          currChildren &&
+          prevChildren &&
+          JSON.stringify(currRest) === JSON.stringify(prevRest)
+        ) {
+          const next = {
+            ...prevRest,
+            children: [...prevChildren, ...currChildren],
+          }
+          return nextChildren
+            .slice(0, -1)
+            .concat(this.#maybeMergeChildren(next))
+        }
+      }
+      return nextChildren.concat(child)
+    }, [] as MarkdownNode[])
+
+    return node
+  }
+
+  /// @internal
+  #createMarkdownNode = (element: SerializerStackElement) => {
+    const node: MarkdownNode = {
+      ...element.props,
+      type: element.type,
+    }
+
+    if (element.children) node.children = element.children
+
+    if (element.value) node.value = element.value
+
+    return node
+  }
+
+  /// Open a new node, the next operations will
+  /// add nodes into that new node until `closeNode` is called.
+  openNode = (type: string, value?: string, props?: JSONRecord) => {
+    this.open(SerializerStackElement.create(type, undefined, value, props))
+    return this
+  }
+
+  #moveSpaces = (
+    element: SerializerStackElement,
+    onPush: () => MarkdownNode
+  ) => {
+    let startSpaces = ''
+    let endSpaces = ''
+    const children = element.children
+    let first = -1
+    let last = -1
+    const findIndex = (node: MarkdownNode[]) => {
+      if (!node) return
+      node.forEach((child, index) => {
+        if (child.type === 'text' && child.value) {
+          if (first < 0) first = index
+
+          last = index
+        }
+      })
+    }
+
+    if (children) {
+      findIndex(children)
+      const lastChild = children?.[last] as
+        | (MarkdownNode & { value: string })
+        | undefined
+      const firstChild = children?.[first] as
+        | (MarkdownNode & { value: string })
+        | undefined
+      if (lastChild && lastChild.value.endsWith(' ')) {
+        const text = lastChild.value
+        const trimmed = text.trimEnd()
+        endSpaces = text.slice(trimmed.length)
+        lastChild.value = trimmed
+      }
+      if (firstChild && firstChild.value.startsWith(' ')) {
+        const text = firstChild.value
+        const trimmed = text.trimStart()
+        startSpaces = text.slice(0, text.length - trimmed.length)
+        firstChild.value = trimmed
+      }
+    }
+
+    if (startSpaces.length) this.#addNodeAndPush('text', undefined, startSpaces)
+
+    const result = onPush()
+
+    if (endSpaces.length) this.#addNodeAndPush('text', undefined, endSpaces)
+
+    return result
+  }
+
+  /// @internal
+  #closeNodeAndPush = (trim: boolean = false): MarkdownNode => {
+    const element = this.close()
+
+    const onPush = () =>
+      this.#addNodeAndPush(
+        element.type,
+        element.children,
+        element.value,
+        element.props
+      )
+
+    if (trim) return this.#moveSpaces(element, onPush)
+
+    return onPush()
+  }
+
+  /// Close the current node and push it into the parent node.
+  closeNode = () => {
+    this.#closeNodeAndPush()
+    return this
+  }
+
+  /// @internal
+  #addNodeAndPush = (
+    type: string,
+    children?: MarkdownNode[],
+    value?: string,
+    props?: JSONRecord
+  ): MarkdownNode => {
+    const element = SerializerStackElement.create(type, children, value, props)
+    const node: MarkdownNode = this.#maybeMergeChildren(
+      this.#createMarkdownNode(element)
+    )
+    this.push(node)
+    return node
+  }
+
+  /// Add a node into current node.
+  addNode = (
+    type: string,
+    children?: MarkdownNode[],
+    value?: string,
+    props?: JSONRecord
+  ) => {
+    this.#addNodeAndPush(type, children, value, props)
+    return this
+  }
+
+  /// @internal
+  #openMark = (
+    mark: Mark,
+    type: string,
+    value?: string,
+    props?: JSONRecord
+  ) => {
+    const isIn = mark.isInSet(this.#marks)
+
+    if (isIn) return this
+
+    this.#marks = mark.addToSet(this.#marks)
+    return this.openNode(type, value, { ...props, isMark: true })
+  }
+
+  /// @internal
+  #closeMark = (mark: Mark): void => {
+    const isIn = mark.isInSet(this.#marks)
+
+    if (!isIn) return
+
+    this.#marks = mark.type.removeFromSet(this.#marks)
+    this.#closeNodeAndPush(true)
+  }
+
+  /// Open a new mark, the next nodes added will have that mark.
+  /// The mark will be closed automatically.
+  withMark = (mark: Mark, type: string, value?: string, props?: JSONRecord) => {
+    this.#openMark(mark, type, value, props)
+    return this
+  }
+
+  /// Close a opened mark.
+  /// In most cases you don't need this because
+  /// marks will be closed automatically.
+  closeMark = (mark: Mark) => {
+    this.#closeMark(mark)
+    return this
+  }
+
+  /// @internal
+  build = (): MarkdownNode => {
+    let doc: MarkdownNode | null = null
+    do doc = this.#closeNodeAndPush()
+    while (this.size())
+
+    return doc
+  }
+
+  /// Give the node or node list back to the state and
+  /// the state will find a proper runner (by `match` method in serializer spec) to handle it.
+  next = (nodes: Node | Fragment) => {
+    if (isFragment(nodes)) {
+      nodes.forEach((node) => {
+        this.#runNode(node)
+      })
+      return this
+    }
+    this.#runNode(nodes)
+    return this
+  }
+
+  /// Use a remark parser to serialize current AST stored.
+  override toString = (remark: RemarkParser): string =>
+    remark.stringify(this.build() as Root)
+
+  /// Transform a prosemirror node tree into remark AST.
+  run = (tree: Node) => {
+    this.next(tree)
+
+    return this
+  }
+}

package/src/serializer/types.ts

@@ -0,0 +1,51 @@
+import type { Mark, Node } from '@jvs-milkdown/prose/model'
+
+import type { SerializerState } from './state'
+
+/// The serializer type which is used to transform prosemirror node into markdown text.
+export type Serializer = (content: Node) => string
+
+/// The spec for node serializer in schema.
+export interface NodeSerializerSpec {
+  /// The match function to check if the node is the target node.
+  /// For example:
+  ///
+  /// ```typescript
+  /// match: (node) => node.type.name === 'paragraph'
+  /// ```
+  match: (node: Node) => boolean
+  /// The runner function to transform the node into markdown text.
+  /// Generally, you should call methods in `state` to add node to state.
+  /// For example:
+  ///
+  /// ```typescript
+  /// runner: (state, node) => {
+  ///   state
+  ///     .openNode(node.type.name)
+  ///     .next(node.content)
+  ///     .closeNode();
+  /// }
+  /// ```
+  runner: (state: SerializerState, node: Node) => void
+}
+
+/// The spec for mark serializer in schema.
+export interface MarkSerializerSpec {
+  /// The match function to check if the node is the target mark.
+  /// For example:
+  ///
+  /// ```typescript
+  /// match: (mark) => mark.type.name === 'emphasis'
+  /// ```
+  match: (mark: Mark) => boolean
+  /// The runner function to transform the node into markdown text.
+  /// Generally, you should call methods in `state` to add mark to state.
+  /// For example:
+  ///
+  /// ```typescript
+  /// runner: (state, mark, node) => {
+  ///   state.withMark(mark, 'emphasis');
+  /// }
+  /// ```
+  runner: (state: SerializerState, mark: Mark, node: Node) => void | boolean
+}

package/src/utility/index.ts

@@ -0,0 +1,2 @@
+export * from './stack'
+export * from './types'

package/src/utility/stack.spec.ts

@@ -0,0 +1,30 @@
+import { expect, it } from 'vitest'
+
+import { Stack } from './stack'
+
+it('stack', () => {
+  const stack = new Stack<number, Array<number>>()
+
+  expect(stack.size()).toBe(0)
+
+  stack.open([])
+  stack.push(1)
+
+  expect(stack.size()).toBe(1)
+  expect(stack.top()).toEqual([1])
+
+  stack.open([])
+  stack.push(2)
+
+  expect(stack.size()).toBe(2)
+  expect(stack.top()).toEqual([2])
+
+  stack.push(3)
+  const a = stack.close()
+  expect(a).toEqual([2, 3])
+  expect(stack.size()).toBe(1)
+
+  const b = stack.close()
+  expect(b).toEqual([1])
+  expect(stack.size()).toBe(0)
+})

package/src/utility/stack.ts

@@ -0,0 +1,48 @@
+import { stackOverFlow } from '@jvs-milkdown/exception'
+
+/// The element of the stack, which holds an array of nodes.
+export abstract class StackElement<Node> {
+  /// A method that can `push` a node into the element.
+  abstract push(node: Node, ...rest: Node[]): void
+}
+
+/// The stack that is used to store the elements.
+///
+/// > Generally, you don't need to use this class directly.
+///
+/// When using the stack, users can call `stack.open` to push a new element into the stack.
+/// And use `stack.push` to push a node into the top element.
+/// Then use `stack.close` to close the top element and pop it.
+///
+/// For example: `stack.open(A).push(B).push(C).close()` will generate a structure like `A(B, C)`.
+export class Stack<Node, Element extends StackElement<Node>> {
+  protected elements: Element[] = []
+
+  /// Get the size of the stack.
+  size = (): number => {
+    return this.elements.length
+  }
+
+  /// Get the top element of the stack.
+  top = (): Element | undefined => {
+    return this.elements.at(-1)
+  }
+
+  /// Push a node into the top element.
+  push = (node: Node): void => {
+    this.top()?.push(node)
+  }
+
+  /// Push a new element.
+  open = (node: Element): void => {
+    this.elements.push(node)
+  }
+
+  /// Close the top element and pop it.
+  close = (): Element => {
+    const el = this.elements.pop()
+    if (!el) throw stackOverFlow()
+
+    return el
+  }
+}

package/src/utility/types.ts

@@ -0,0 +1,63 @@
+import type { MarkSpec, NodeSpec } from '@jvs-milkdown/prose/model'
+import type { remark } from 'remark'
+import type { Plugin, Transformer } from 'unified'
+
+import type { MarkParserSpec, NodeParserSpec } from '../parser/types'
+import type {
+  MarkSerializerSpec,
+  NodeSerializerSpec,
+} from '../serializer/types'
+
+/// @internal
+export type Node = Parameters<Transformer>[0]
+
+/// @internal
+export type Root = Parameters<(typeof remark)['stringify']>[0]
+
+/// @internal
+export type JSONValue =
+  | string
+  | number
+  | boolean
+  | null
+  | JSONValue[]
+  | { [key: string]: JSONValue }
+
+/// @internal
+export type JSONRecord = Record<string, JSONValue>
+
+/// @internal
+export type RemarkPluginRaw<T> = Plugin<[T], Root>
+
+/// The universal type of a [remark plugin](https://github.com/remarkjs/remark/blob/main/doc/plugins.md).
+export interface RemarkPlugin<T = Record<string, unknown>> {
+  plugin: Plugin<[T], Root>
+  options: T
+}
+
+/// The type of [remark instance](https://github.com/remarkjs/remark/tree/main/packages/remark#remark-1).
+export type RemarkParser = ReturnType<typeof remark>
+
+/// The universal type of a node in [mdast](https://github.com/syntax-tree/mdast).
+export type MarkdownNode = Node & {
+  children?: MarkdownNode[]
+  [x: string]: unknown
+}
+
+/// Schema spec for node. It is a super set of [NodeSpec](https://prosemirror.net/docs/ref/#model.NodeSpec).
+export interface NodeSchema extends NodeSpec {
+  /// To markdown serializer spec.
+  readonly toMarkdown: NodeSerializerSpec
+  /// Parse markdown serializer spec.
+  readonly parseMarkdown: NodeParserSpec
+  /// The priority of the node, by default it's 50.
+  readonly priority?: number
+}
+
+/// Schema spec for mark. It is a super set of [MarkSpec](https://prosemirror.net/docs/ref/#model.MarkSpec).
+export interface MarkSchema extends MarkSpec {
+  /// To markdown serializer spec.
+  readonly toMarkdown: MarkSerializerSpec
+  /// Parse markdown serializer spec.
+  readonly parseMarkdown: MarkParserSpec
+}