在vue3中实现富文本--利用defineCustomElement来快速实现富文本组件（二）

SJ7852023-12-31 12:34

一、技术点引入

前一篇文章主要大致说明了如何编写一个简易的富文本编辑器，这篇文章主要讲解如何编写vue的自定义元素，以及如何在富文本中使用。下面是几个技术要点：

  1. vue中的defineCustomElement原理：具体详情请参阅vue官网文章Vue 与 Web Components。简要来说，defineCustomElement方法需要传入一个vue组件，方法会将这个组件解析为一个webcomponent并返回。
  2. webcomponent原理：具体详情请参阅mdnWeb Component。简要来说，webcomponent有三个组成部分：Custom element（自定义元素） 、Shadow DOM（影子 DOM） 以及 HTML template（HTML 模板） ；他还有个特性，也就是自定义元素内部无论有多么复杂的元素结构，浏览器在处理一些事件的时候也总会将其视为一个基本元素 ，而不会将事件触发往里面找触发的具体元素节点。下面将重点说说自定义元素和shadow dom，这也是最重要的坑点
  3. Custom element（自定义元素）：详情请参阅mdn文档使用自定义元素。简要来说，自定义元素是一个类，如果他是一个新的自定义元素（也就是独立元素），那么他就要继承自HTMLElement，如果他想在某个元素上进行修改，则继承自对应的元素（这一点很重要，我们后续给所有自定义元素添加公共样式和元素时就依据这一点）。所以defineCustomElement 方法它返回的也是一个类 。同时，自定义元素需要被注册，此时要调用customElements.define方法，他接受两个入参，第一个是自定义元素名，第二个是自定义元素这个类；具体示例可以参阅mdn，此处不多赘述。
  4. Shadow DOM ：详情请参阅mdn文档使用影子 DOM。这是使用defineCustomElement最 坑 的点，没有之一，后续很多操作都是为了给shadow dom填坑而存在的。其中最重要的便是 CSS样式隔离 ，他带来的好处就是内部样式不会被外部样式污染，但是在这里它是一个坑点而不是好处。。。这代表vue的样式选择器无法选中自定义元素内部，所以vue在解决这个问题时采用了一个方案：它规定自定义元素的单文件组件必须以 .ce.vue 结尾，这样这个组件在编译时就会将组件内定义的所有style标签编译完成后暴露到组件对象的styles中，方便自定义元素时插入style，比如这样：

二、代码实现

  1. 首先我们封装一个基础的CustonLink.ce.vue组件：
js 复制代码 
<!-- CustonLink.ce.vue -->
<script setup lang="ts">
import { ref } from 'vue'

const props = defineProps({
  href: String,
  text: String
})
const hrefRef = ref(props.href || ' ')
const textRef = ref(props.text || props.href || '  ')

const updateText = (e: Event) => {
  textRef.value = (e.target as HTMLLinkElement).textContent || ''
}
</script>
<template>
  <a contenteditable="true" class="link" :href="hrefRef" target="_blank" @input="updateText">{{
    textRef
  }}</a>
</template>
<script lang="ts">
// 组件静态属性要在这里定义，这是初始化时能拿到的
export default {
  name: 'custom-link',
  type: 'inline'
}
</script>

<style lang="less" scoped>
.link {
  outline: 0px solid transparent;
}
</style>

它接受两个参数，一个是文本，一个是链接，并且入参只用于初始化数据，并且一定要注意自定义组件名，不然在调用customElements.define方法时拿不到名字。

  1. 然后，我们写一个index.ts组件，用于注册所有的自定义元素和将这些自定义元素导出：
js 复制代码 
import {  defineCustomElement } from 'vue'
import { customComponentsStore } from '@/stores/customComponents'



import CustomLink from './CustomLink.ce.vue'

const Components = [CustomLink]

type CustomComponents = {
  [key: string]: {
    name: string
    type: 'inline' | 'block'
    nestable: boolean
    props?: {
      [key: string]: string
    }
    Constructor: CustomElementConstructor
  }
}

const customComponents = {
  install() {
    const componentsName: CustomComponents = {}
    Components.forEach((component) => {
      console.log(component);
      
      const CustomElement = defineCustomElement(component)
      const type = component.type ?? 'inline'

      customElements.define(component.name ?? component.__name, CustomElement)
      const name = component.name ?? component.__name
      componentsName[name] = {
        name,
        type,
        nestable: component.nestable ?? false,
        Constructor: CustomElement
      }
      if (component.props) {
        const props = {}
        Object.keys(component.props).forEach((prop) => {
          props[prop] = component.props[prop].name
        })
        componentsName[name].props = props
      }
    })
    const customComponents = customComponentsStore()
    customComponents.setComponents(componentsName)
  }
}

export default customComponents

index.ts主要就是将自定义元素全部注册，并将所有的元素相关信息和构造函数都用pinia保存起来，方便我们的RichText类来使用，并将上述过程打包成install方法，方便main.ts直接app.use完成注册。

  1. RichText.ts也要进行修改：
js 复制代码 
import { type CSSProperties } from './type'
import { customComponentsStore } from '@/stores/customComponents'

// 解决pinia循环引用导致报错的问题
const getCustomComponents = () => {
    return customComponentsStore().getComponents
  }

class RichText {
    private rootElement!: HTMLElement
    private mode!: 'edit' | 'show'
    private focusEl: HTMLElement | null = null
    constructor(
        parent: HTMLElement,
        mode: 'edit' | 'show' = 'edit'
    ) {

        this.initRootNode(parent, mode)
    }

    public getRootElement() {
        return this.rootElement
    }

    private initRootNode(parent: HTMLElement, mode: 'edit' | 'show' = 'edit') {
        this.rootElement = document.createElement('div')
        this.rootElement.contentEditable = mode === 'edit' ? 'true' : 'false'
        parent.appendChild(this.rootElement)
    }
      // 解决shadow dom引发的contenteditable光标丢失
  public insertCustomElement(name: string, props = {}) {
    if (!getCustomComponents()[name]) {
      console.error(`不存在该自定义元素：${name}`)
      return
    }
    // 这种方式新建元素支持不同元素类型，比setAttribute好
    const customComponent = getCustomComponents()[name]
    const componentInstance = new customComponent.Constructor({ ...props })

    const range = this.getCursorRange()
    if (range) {
      if (!range.collapsed) {
        range.deleteContents()
        range.collapse()
      }

      componentInstance.setAttribute('mode', this.mode)
      if (customComponent.type === 'inline') {
        this.insertInlineCustomElement(componentInstance, range)
      } else {
        this.insertBlockCustomElement(componentInstance, range)
      }

      range.collapse(true)
      this.rootElement.focus()
    }
  }

  // 插入行内自定义元素
  private insertInlineCustomElement(el: HTMLElement, range: Range) {
    const container = document.createElement('div')
    container.style.display = 'inline-block'
    container.setAttribute('contenteditable', 'false')
    el.setAttribute('containereditable', 'true')
    container.appendChild(el)
    range.insertNode(container)
  }

  // 插入块级自定义元素
  private insertBlockCustomElement(el: HTMLElement, range: Range) {
    const container = document.createElement('div')
    container.contentEditable = 'false'
    container.appendChild(el)

    const afterContainer = document.createElement('div')
    afterContainer.appendChild(document.createElement('br'))

    range.insertNode(container)
    range.setStartAfter(container)
    range.collapse(true)
    range.insertNode(afterContainer)
    range.setStartAfter(afterContainer)
    range.collapse(true)
  }

    // 这就是向外暴露的修改样式的方法
    public getCustomSelection(styles: CSSProperties) {
        // 获取range
        const range = this.getCursorRange()
        if (range) {
            // 获取到选中区域的公共父级
          const { commonAncestorContainer } = range
            // 根据节点类型判断调用哪个处理的方法
          if (commonAncestorContainer.nodeType === Node.TEXT_NODE) {
            this.processingTextNode(range, styles)
          } else {
            this.processingHTMLNode(range, styles)
          }
        }
      }

    // 获取当前光标位置
    private getCursorRange() {

        const sel = getSelection()
        if (sel && sel.rangeCount) {
            const range = sel.getRangeAt(0)
            // 只允许rootElement的子节点参与修改，不允许本身参与修改
            if (this.rootElement.contains(range.commonAncestorContainer)) return range
        }

        return null
    }

    // 如果是文本节点则需要分裂
    private processingTextNode(range: Range, styles: CSSProperties) {
        const { startContainer, endContainer, startOffset, endOffset, commonAncestorContainer } = range
        // 判断样式是不是设置过了，设置了就不需要继续操作了
        if (this.checkElementStyles(commonAncestorContainer.parentElement!, styles)) return
        // 如果选中的文本为父级的所有文本，则直接修改父级的样式就好，不需要分裂节点
        if (range.cloneContents().textContent === commonAncestorContainer.textContent) {
            this.applyCSSToObject(commonAncestorContainer.parentElement!, styles)
            return
        }
        // 这里代表选中内容为一个文本节点的一部分，这代表要分裂节点了

        // 首先将选中文本之前的文本用一个新的文本节点装起来
        const startRange = new Range()
        startRange.setStartBefore(commonAncestorContainer)
        startRange.setEnd(startContainer, startOffset)
        const startEl = document.createTextNode(startRange.cloneContents().textContent || '')
        startRange.detach()

        // 然后将选中文本之后的文本用一个新的文本节点装起来
        const endRange = new Range()
        endRange.setStart(endContainer, endOffset)
        endRange.setEndAfter(commonAncestorContainer)
        const endEl = document.createTextNode(endRange.cloneContents().textContent || '')
        endRange.detach()

        // 将选中的文本用一个span标签装起来，并将样式放在span标签上
        const targetEl = document.createElement('span')
        const textNode = document.createTextNode(range.cloneContents().textContent || '')
        targetEl.appendChild(textNode)
        this.applyCSSToObject(targetEl, styles)
        range.detach()

        // 按照顺序将节点插入到公共文本节点的父节点中，然后将公共文本节点删除掉
        commonAncestorContainer.parentNode?.insertBefore(startEl, commonAncestorContainer)
        commonAncestorContainer.parentNode?.insertBefore(targetEl, commonAncestorContainer)
        commonAncestorContainer.parentNode?.insertBefore(endEl, commonAncestorContainer)
        commonAncestorContainer.textContent = ''
        commonAncestorContainer.parentNode?.removeChild(commonAncestorContainer)
    }

    // 如果是元素节点则需要找到所有文本节点，并按照分区进行截断设置或者全部设置
    private processingHTMLNode(range: Range, styles: CSSProperties) {
        const { startContainer, endContainer, startOffset, endOffset, commonAncestorContainer } = range

        // 这个函数是不断地找公共父元素中，所有与选中文本相交的文本节点，
        const textNodesUnder = (root: Node) => {
            const textNodes: Node[] = []
            const addTextNodes = (el: Node) => {
                if (el.nodeType === Node.TEXT_NODE && range.intersectsNode(el)) {
                    textNodes.push(el)
                } else {
                    for (let i = 0, len = el.childNodes.length; i < len; ++i) {
                        addTextNodes(el.childNodes[i])
                    }
                }
            }
            addTextNodes(root)
            return textNodes
        }

        const textNodes = textNodesUnder(commonAncestorContainer)

        // 接下来只需要处理与选中区域相交的最底层节点就好了
        textNodes.forEach((node) => {
            // 同样的先判断是不是样式一样的，一样的就不继续处理了
            if (node.parentElement && this.checkElementStyles(node.parentElement, styles)) return

            if (node === startContainer) {
                // 如果是开头的文本节点，则要分裂成左右两部分，右侧要装在span设置为新样式
                console.log('start---->', startContainer)
                const [lText, rText] = this.splitStr(startContainer.textContent || '', startOffset)
                const lTextNode = document.createTextNode(lText)
                const rTextNode = document.createTextNode(rText)
                const rTextEl = document.createElement('span')
                this.applyCSSToObject(rTextEl, styles)
                rTextEl.appendChild(rTextNode)
                node.parentNode?.insertBefore(lTextNode, node)
                node.parentNode?.replaceChild(rTextEl, node)
            } else if (node === endContainer) {
                // 如果是结尾的文本节点，则要分裂成左右两部分，左侧要装在span设置为新样式
                console.log('end---->', endContainer)
                const [lText, rText] = this.splitStr(endContainer.textContent || '', endOffset)
                const lTextNode = document.createTextNode(lText)
                const rTextNode = document.createTextNode(rText)
                const lTextEl = document.createElement('span')
                this.applyCSSToObject(lTextEl, styles)
                lTextEl.appendChild(lTextNode)
                node.parentNode?.insertBefore(lTextEl, node)
                node.parentNode?.replaceChild(rTextNode, node)
            } else {
                // 如果是中间节点，则直接全部装起来，设置样式
                console.log('center-->', node)
                const text = node.textContent
                const textNode = document.createTextNode(text || '')
                const textEl = document.createElement('span')
                this.applyCSSToObject(textEl, styles)
                textEl.appendChild(textNode)
                node.parentNode?.replaceChild(textEl, node)
            }
        })
    }

    // 将样式设置到节点
    private applyCSSToObject(element: HTMLElement, cssObject: CSSProperties): void {
        Object.assign(element.style, cssObject)
    }

    // 检查样式是否都设置了，如果设置了就不需要重复设置了
    private checkElementStyles(element: HTMLElement, cssObject: CSSProperties): boolean {
        const elementStyles = window.getComputedStyle(element)
        for (const prop in cssObject) {
            if (Object.prototype.hasOwnProperty.call(cssObject, prop)) {
                if (elementStyles[prop] !== cssObject[prop]) {
                    return false
                }
            }
        }

        return true
    }

    private splitStr(str: string, offset: number) {
        return [str.slice(0, offset), str.slice(offset)]
    }
}

新增的部分主要做了这些事情：

  1. insertCustomElement方法首先检查要插入的自定义元素是否存在，
  2. 如果存在则用vue的方式通过new方法使用自定义元素，这样使用的好处是：它允许传递不同类型的参数进去，如果使用document.createElement来创建自定义元素，再使用setAttribute设置属性的话，设置的属性仅仅支持string类型，在使用的过程中会增加两步将对象转换为字符串再将字符串转换为对应类型的问题，这是没有必要的
  3. 接着拿到当前的光标位置，删除选中的所有元素，再根据自定义元素的类型来调用不同的方法处理如何插入的问题

尝试插入CustomLink:

js 复制代码 
import { ref, onMounted, reactive } from 'vue'
import { RichText } from '@/utils/richText/RichText'

let handleClickBtn: (styles: any) => void
let insertLink: (text: string, href: string) => void
const parent = ref()
onMounted(() => {
  const richText = new RichText(parent.value,)
  // 下面是一些btn实现
  handleClickBtn = (styles) => richText.getCustomSelection(styles)
  insertLink = (text, href) => {
    richText.insertCustomElement('custom-link', { href, text })
  }
})
html 复制代码 
<template>
  <button @click="handleClickBtn({ color: 'rgb(255, 0, 0)' })">
    更改文字为红色
  </button>
  <button @click="insertLink('baidu', '//www.baidu.com')">插入链接</button>
  <div ref="parent" class="parent"></div>
</template>

实现后的效果为：

其中的text内容是可以编辑的，href则只能初始化一次，不可更改（当然修改CustomLink组件也能实现更改）

可能读者会好奇，为什么插入过程那么复杂，为什么不能直接将新建的元素直接插入进去，外面还要包裹一层div并将其contentEditable设置为'false'；这就不得不说到webcomponent的特性了：如果我们直接将自定义元素插入到富文本中，则会发生一件事情，那就是当富文本为空的时候插入这个CustomLink后，光标再也无法聚焦到CustomLink外部了，只能编辑CustomLink内部的内容，这就是注释中写的解决shadow dom引发的contenteditable光标丢失的含义。读者可以自行尝试直接插入的结果，将插入行内元素改为这样：

js 复制代码 
  // 插入行内自定义元素
  private insertInlineCustomElement(el: HTMLElement, range: Range) {
    // const container = document.createElement('div')
    // container.style.display = 'inline-block'
    // container.setAttribute('contenteditable', 'false')
    // el.setAttribute('containereditable', 'true')
    // container.appendChild(el)
    range.insertNode(el)
  }

即使按照这个办法解决了光标只能聚焦到自定义元素内部的问题，但是他还是有点小毛病，那就是当光标在自定义元素外部右侧时会消失，不过不影响使用。我去调研了一下知乎的富文本编辑，当他插入一个公式时也会触发这个小问题，他们的解决办法是给元素外部左右都加一个空格，然后让光标聚到空格后面，这样就能展示光标了，大概是这样：

这样也是治标不治本的，当用户删除掉这个空格依然会让光标消失，不过不影响输入就是了。

最后再贴上一个block类型的组件CodeEditor，这是一个简陋的版本，用作示例：

js 复制代码 
<script setup lang="ts">
import { onMounted, ref, onBeforeUnmount } from 'vue'
const props = defineProps({
  mode: String,
  defaultContent: String
})

const content = ref(props.defaultContent)
const code = ref()
const textarea = ref()
let rowNumber = ref(1)

const setLineHeight = () => {
  const activeEl = code.value ?? textarea.value.$el
  const height = parseInt(getComputedStyle(activeEl).height)
  rowNumber.value = Math.ceil(height / 24)
}
const observer = new ResizeObserver(setLineHeight)

onMounted(() => {
  if (code.value) {
    observer.observe(code.value, { box: 'border-box' })
  }
  if (textarea.value) {
    observer.observe(textarea.value.$el, { box: 'border-box' })
  }
})

onBeforeUnmount(() => {
  if (code.value) {
    observer.unobserve(code.value)
  }
  if (textarea.value) {
    observer.unobserve(textarea.value.$el)
  }
})

defineExpose({
  defaultContent: content
})
</script>

<template>
  <div class="code-container">
    <ul class="list-number">
      <li v-for="num in rowNumber" :key="num">{{ num }}</li>
    </ul>
    <pre class="code" v-if="mode === 'show'"><code><div  tabindex="0" ref="code">{{ content }}</div></code></pre>
    <a-textarea ref="textarea" v-else v-model:value="content" placeholder="请输入/粘贴代码" auto-size />
  </div>
</template>

<script lang="ts">
export default {
  name: 'code-editor',
  type: 'block'
}
</script>
<style lang="less">
.code-container {
  background-color: rgb(31, 31, 31);
  color: rgb(204, 204, 204);
  font-family: Consolas, 'Courier New', monospace;
  font-size: 18px;
  position: relative;
  display: flex;
  padding: 5px 0;
}

.code {
  flex: 1;
  width: calc(100% - 48px);
  line-height: 24px;
  margin: 0;
  background-color: rgb(31, 31, 31);
  padding: 0 8px;
  box-sizing: border-box;

  div {
    overflow-x: auto;
  }
}

textarea {
  padding: 0 8px;
  box-sizing: border-box;
  width: 100%;
  background-color: rgb(31, 31, 31);
  line-height: 24px;
  font-size: 18px;
  color: rgb(204, 204, 204);
  font-family: Consolas, 'Courier New', monospace;
  outline: none;
  border: none;
}

.list-number {
  overflow-x: auto;
  list-style: none;
  width: 48px;
  margin: 0;
  padding: 0 8px;
  box-sizing: border-box;
  text-align: right;
  border-right: 1px #ebebeb solid;
  background-color: rgb(31, 31, 31);

  &>li {
    line-height: 24px;
  }
}
</style>

这里主要是用到了ResizeObserver来监听textarea高，然后根据高度来计算有多少行了。 他的效果为：

细心的朋友可能会发现，我使用了antdv的组件textarea，但是我仅仅设置了我想要的样式就实现了效果，antdv的默认样式好像丢失了一样，这就是shadow dom样式隔离带来的后果，我们最后会着手解决这个问题。

三、总结

本文主要介绍了在基础的富文本编辑上如何使用vue的defineCustomElement来将一个vue单文件组件打包成一个自定义元素，并如何注册一个自定义元素，以及在插入自定义元素时利用嵌套盒子来避免光标聚焦问题的出现。下一篇文章我将要介绍如何给自定义元素加上一些统一的样式，元素和逻辑

相关推荐
y先森5 小时前
CSS3中的伸缩盒模型（弹性盒子、弹性布局）之伸缩容器、伸缩项目、主轴方向、主轴换行方式、复合属性flex-flow
前端·css·css3
前端Hardy5 小时前
纯HTML&CSS实现3D旋转地球
前端·javascript·css·3d·html
susu10830189115 小时前
vue3中父div设置display flex，2个子div重叠
前端·javascript·vue.js
IT女孩儿6 小时前
CSS查缺补漏（补充上一条）
前端·css
吃杠碰小鸡7 小时前
commitlint校验git提交信息
前端
虾球xz7 小时前
游戏引擎学习第20天
前端·学习·游戏引擎
我爱李星璇8 小时前
HTML常用表格与标签
前端·html
疯狂的沙粒8 小时前
如何在Vue项目中应用TypeScript？应该注意那些点？
前端·vue.js·typescript
小镇程序员8 小时前
vue2 src_Todolist全局总线事件版本
前端·javascript·vue.js
野槐8 小时前
前端图像处理(一)
前端
热门推荐
01ICLR24大模型提示(1/11) | BadChain：大型语言模型的后门思维链提示02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04【音视频 | opus】opus编解码库(opus-1.4)详细介绍以及使用——附带解码示例代码05Coze扣子平台完整体验和实践（附国内和国际版对比）06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07IT专业入门，高考假期预习指南08玄机平台应急响应—webshell查杀09RAG 实践- Ollama+RagFlow 部署本地知识库10你还在傻傻的打开页面输用户名和密码？来我教你实现自动化