@jvs-milkdown/utils 1.0.0

package/src/macro/replace-all.ts

@@ -0,0 +1,46 @@
+import type { Ctx } from '@jvs-milkdown/ctx'
+
+import {
+  editorStateOptionsCtx,
+  editorViewCtx,
+  parserCtx,
+  prosePluginsCtx,
+  schemaCtx,
+} from '@jvs-milkdown/core'
+import { Slice } from '@jvs-milkdown/prose/model'
+import { EditorState } from '@jvs-milkdown/prose/state'
+
+/// Replace all content of the editor with markdown string.
+/// If flush is true, the editor state will be re-created.
+export function replaceAll(markdown: string, flush = false) {
+  return (ctx: Ctx): void => {
+    const view = ctx.get(editorViewCtx)
+    const parser = ctx.get(parserCtx)
+    const doc = parser(markdown)
+    if (!doc) return
+
+    if (!flush) {
+      const { state } = view
+      return view.dispatch(
+        state.tr.replace(
+          0,
+          state.doc.content.size,
+          new Slice(doc.content, 0, 0)
+        )
+      )
+    }
+
+    const schema = ctx.get(schemaCtx)
+    const overrideOptions = ctx.get(editorStateOptionsCtx)
+    const plugins = ctx.get(prosePluginsCtx)
+    const newOptions = overrideOptions({
+      schema,
+      doc,
+      plugins,
+    })
+
+    const state = EditorState.create(newOptions)
+
+    view.updateState(state)
+  }
+}

package/src/macro/replace-range.ts

@@ -0,0 +1,18 @@
+import type { Ctx } from '@jvs-milkdown/ctx'
+
+import { editorViewCtx } from '@jvs-milkdown/core'
+
+import { markdownToSlice } from './markdown-to-slice'
+
+/// Replace the content of the given range with the markdown string.
+export function replaceRange(
+  markdown: string,
+  range: { from: number; to: number }
+) {
+  return (ctx: Ctx) => {
+    const view = ctx.get(editorViewCtx)
+    const slice = markdownToSlice(markdown)(ctx)
+
+    view.dispatch(view.state.tr.replace(range.from, range.to, slice))
+  }
+}

package/src/macro/set-attr.ts

@@ -0,0 +1,16 @@
+import type { Ctx } from '@jvs-milkdown/ctx'
+import type { Attrs } from '@jvs-milkdown/prose/model'
+
+import { editorViewCtx } from '@jvs-milkdown/core'
+
+/// Set the attributes of the node at the given position.
+export function setAttr(pos: number, update: (prevAttrs: Attrs) => Attrs) {
+  return (ctx: Ctx) => {
+    const view = ctx.get(editorViewCtx)
+    const { tr } = view.state
+    const node = tr.doc.nodeAt(pos)
+    if (!node) return
+    const nextAttr = update(node.attrs)
+    return view.dispatch(tr.setNodeMarkup(pos, undefined, nextAttr))
+  }
+}

package/src/pipe.ts

@@ -0,0 +1,72 @@
+/// @internal
+export type Many<T> = T | ReadonlyArray<T>
+
+interface Pipe {
+  pipe: (<A extends any[], R1, R2, R3, R4, R5, R6, R7>(
+    f1: (...args: A) => R1,
+    f2: (a: R1) => R2,
+    f3: (a: R2) => R3,
+    f4: (a: R3) => R4,
+    f5: (a: R4) => R5,
+    f6: (a: R5) => R6,
+    f7: (a: R6) => R7
+  ) => (...args: A) => R7) &
+    (<A extends any[], R1, R2, R3, R4, R5, R6, R7>(
+      f1: (...args: A) => R1,
+      f2: (a: R1) => R2,
+      f3: (a: R2) => R3,
+      f4: (a: R3) => R4,
+      f5: (a: R4) => R5,
+      f6: (a: R5) => R6,
+      f7: (a: R6) => R7,
+      ...func: Array<Many<(a: any) => any>>
+    ) => (...args: A) => any) &
+    (<A extends any[], R1, R2, R3, R4, R5, R6>(
+      f1: (...args: A) => R1,
+      f2: (a: R1) => R2,
+      f3: (a: R2) => R3,
+      f4: (a: R3) => R4,
+      f5: (a: R4) => R5,
+      f6: (a: R5) => R6
+    ) => (...args: A) => R6) &
+    (<A extends any[], R1, R2, R3, R4, R5>(
+      f1: (...args: A) => R1,
+      f2: (a: R1) => R2,
+      f3: (a: R2) => R3,
+      f4: (a: R3) => R4,
+      f5: (a: R4) => R5
+    ) => (...args: A) => R5) &
+    (<A extends any[], R1, R2, R3, R4>(
+      f1: (...args: A) => R1,
+      f2: (a: R1) => R2,
+      f3: (a: R2) => R3,
+      f4: (a: R3) => R4
+    ) => (...args: A) => R4) &
+    (<A extends any[], R1, R2, R3>(
+      f1: (...args: A) => R1,
+      f2: (a: R1) => R2,
+      f3: (a: R2) => R3
+    ) => (...args: A) => R3) &
+    (<A extends any[], R1, R2>(
+      f1: (...args: A) => R1,
+      f2: (a: R1) => R2
+    ) => (...args: A) => R2) &
+    ((...func: Array<Many<(...args: any[]) => any>>) => (...args: any[]) => any)
+}
+
+/// @internal
+export const pipe: Pipe['pipe'] = (...funcs: any[]) => {
+  const length = funcs.length
+  let index = length
+  while (index--) {
+    if (typeof funcs[index] !== 'function')
+      throw new TypeError('Expected a function')
+  }
+  return (...args: any[]) => {
+    let index = 0
+    let result = length ? funcs[index](...args) : args[0]
+    while (++index < length) result = funcs[index](result)
+
+    return result
+  }
+}