@jvs-milkdown/plugin-automd 1.0.0

package/src/replacer.ts

@@ -0,0 +1,62 @@
+import type { Ctx } from '@jvs-milkdown/ctx'
+import type { Attrs } from '@jvs-milkdown/prose/model'
+import type { EditorState, PluginKey, Transaction } from '@jvs-milkdown/prose/state'
+
+import { TextSelection } from '@jvs-milkdown/prose/state'
+
+import { inlineSyncConfig } from './config'
+import { getContextByState } from './context'
+import { linkRegexp } from './regexp'
+import { calcOffset } from './utils'
+
+export function runReplacer(
+  ctx: Ctx,
+  key: PluginKey,
+  state: EditorState,
+  dispatch: (tr: Transaction) => void,
+  attrs: Attrs
+) {
+  const { placeholderConfig } = ctx.get(inlineSyncConfig.key)
+  const holePlaceholder = placeholderConfig.hole
+  // insert a placeholder to restore the selection
+  let tr = state.tr
+    .setMeta(key, true)
+    .insertText(holePlaceholder, state.selection.from)
+
+  const nextState = state.apply(tr)
+  const context = getContextByState(ctx, nextState)
+
+  if (!context) return
+
+  const lastUserInput = context.text.slice(
+    0,
+    context.text.indexOf(context.placeholder)
+  )
+
+  const { $from } = nextState.selection
+  const from = $from.before()
+  const to = $from.after()
+
+  const offset = calcOffset(context.nextNode, from, context.placeholder)
+
+  tr = tr
+    .replaceWith(from, to, context.nextNode)
+    .setNodeMarkup(from, undefined, attrs)
+    // delete the placeholder
+    .delete(offset + 1, offset + 2)
+
+  // restore the selection
+  tr = tr.setSelection(TextSelection.near(tr.doc.resolve(offset + 1)))
+
+  const needsRestoreMark =
+    linkRegexp.test(lastUserInput) ||
+    ['*', '_', '~'].includes(lastUserInput.at(-1) || '')
+  if (needsRestoreMark && tr.selection instanceof TextSelection) {
+    const marks = tr.selection.$cursor?.marks() ?? []
+    marks.forEach((mark) => {
+      tr = tr.removeStoredMark(mark.type)
+    })
+  }
+
+  dispatch(tr)
+}

package/src/utils.ts

@@ -0,0 +1,91 @@
+import type { Node } from '@jvs-milkdown/prose/model'
+
+import type { SyncNodePlaceholder } from './config'
+
+import {
+  asterisk,
+  asteriskHolder,
+  keepLinkRegexp,
+  punctuationRegexp,
+  underline,
+  underlineHolder,
+} from './regexp'
+
+export function keepLink(str: string) {
+  let text = str
+  let match = text.match(keepLinkRegexp)
+  while (match && match.groups) {
+    const { span } = match.groups
+    text = text.replace(keepLinkRegexp, span as string)
+
+    match = text.match(keepLinkRegexp)
+  }
+  return text
+}
+
+export function mergeSlash(str: string) {
+  return str
+    .replaceAll(/\\\\\*/g, asterisk)
+    .replaceAll(/\\\\_/g, underline)
+    .replaceAll(asterisk, asteriskHolder)
+    .replaceAll(underline, underlineHolder)
+}
+
+export function swap(text: string, first: number, last: number) {
+  const arr = text.split('')
+  const temp = arr[first]
+  if (arr[first] && arr[last]) {
+    arr[first] = arr[last] as string
+    arr[last] = temp as string
+  }
+  return arr.join('').toString()
+}
+
+export function replacePunctuation(holePlaceholder: string) {
+  return (text: string) => text.replace(punctuationRegexp(holePlaceholder), '')
+}
+
+export function calculatePlaceholder(placeholder: SyncNodePlaceholder) {
+  return (text: string) => {
+    const index = text.indexOf(placeholder.hole)
+    const left = text.charAt(index - 1)
+    const right = text.charAt(index + 1)
+    const notAWord = /[^\w]|_/
+
+    // cursor on the right
+    if (!right) return placeholder.punctuation
+
+    // cursor on the left
+    if (!left) return placeholder.char
+
+    if (notAWord.test(left) && notAWord.test(right))
+      return placeholder.punctuation
+
+    return placeholder.char
+  }
+}
+
+export function calcOffset(node: Node, from: number, placeholder: string) {
+  let offset = from
+  let find = false
+  node.descendants((n) => {
+    if (find) return false
+    if (!n.textContent.includes(placeholder)) {
+      offset += n.nodeSize
+      return false
+    }
+    if (n.isText) {
+      const i = n.text?.indexOf(placeholder)
+      if (i != null && i >= 0) {
+        find = true
+        offset += i
+        return false
+      }
+    }
+
+    // enter the node
+    offset += 1
+    return true
+  })
+  return offset
+}