fix: duplicate marks support (#9969)

Signed-off-by: Alexander Onnikov <[email protected]>

Author: aonnikov

common/config/rush/pnpm-lock.yaml

@@ -40,7 +40,8 @@
   },
   "dependencies": {
     "@hcengineering/core": "^0.6.32",
-    "fast-equals": "^5.2.2"
+    "fast-equals": "^5.2.2",
+    "hash-it": "^6.0.0"
   },
   "repository": "https://github.com/hcengineering/platform",
   "publishConfig": {

packages/text-core/package.json

@@ -0,0 +1,49 @@
+import { hashAttrs, stripHash } from '../utils'
+
+describe('hashAttrs', () => {
+  it('should return a hash of length 8', () => {
+    const attrs = { a: 1 }
+    const hash = hashAttrs(attrs)
+    expect(hash.length).toEqual(8)
+  })
+  it('should return the same hash for the same attrs', () => {
+    const attrs = { a: 1, b: 2 }
+    const hash1 = hashAttrs(attrs)
+    const hash2 = hashAttrs(attrs)
+    expect(hash1).toEqual(hash2)
+  })
+
+  it('should return different hashes for different attrs', () => {
+    const attrs1 = { a: 1, b: 2 }
+    const attrs2 = { a: 1, b: 3 }
+    const hash1 = hashAttrs(attrs1)
+    const hash2 = hashAttrs(attrs2)
+    expect(hash1).not.toEqual(hash2)
+  })
+})
+
+describe('stripHash', () => {
+  it('should return the name without the hash', () => {
+    const name = 'bold--c0decafe'
+    const result = stripHash(name)
+    expect(result).toEqual('bold')
+  })
+
+  it('should return the original name if no hash is present', () => {
+    const name = 'bold'
+    const result = stripHash(name)
+    expect(result).toEqual(name)
+  })
+
+  it('should return the original name if the hash is not 8 characters long', () => {
+    const name = 'bold--1234567'
+    const result = stripHash(name)
+    expect(result).toEqual(name)
+  })
+
+  it('should return the original name if the hash is not a valid base64 string', () => {
+    const name = 'bold--invalid!'
+    const result = stripHash(name)
+    expect(result).toEqual(name)
+  })
+})

packages/text-core/src/markup/__tests__/utils.test.ts

@@ -16,9 +16,11 @@
 import { Markup } from '@hcengineering/core'
 
 import { deepEqual } from 'fast-equals'
+import hashIt from 'hash-it'
+
 import { nodeDoc, nodeParagraph, nodeText } from './dsl'
-import { MarkupMark, MarkupNode, MarkupNodeType, emptyMarkupNode } from './model'
-import { traverseNode } from './traverse'
+import { MarkupMark, MarkupMarkType, MarkupNode, MarkupNodeType, emptyMarkupNode } from './model'
+import { traverseAllMarks, traverseNode } from './traverse'
 
 /** @public */
 export const EmptyMarkup: Markup = jsonToMarkup(emptyMarkupNode())
@@ -124,7 +126,11 @@ export function markupToJSON (markup: Markup): MarkupNode {
     // But there seem to be some cases when it contains HTML or plain text
     // So we need to handle those cases and produce valid MarkupNode
     if (markup.startsWith('{')) {
-      return JSON.parse(markup) as MarkupNode
+      const json = JSON.parse(markup) as MarkupNode
+      traverseAllMarks(json, (node, mark) => {
+        mark.type = stripHash(mark.type) as MarkupMarkType
+      })
+      return json
     } else {
       return nodeDoc(nodeParagraph(nodeText(markup)))
     }
@@ -207,3 +213,17 @@ export function markupToText (markup: Markup): string {
 
   return fragments.join('').trim()
 }
+
+// see https://github.com/yjs/y-prosemirror/blob/master/src/lib.js#L402
+const hashedMarkNameRegex = /(.*)(--[a-zA-Z0-9+/=]{8})$/
+
+/** @public */
+export function stripHash (attrName: string): string {
+  return hashedMarkNameRegex.exec(attrName)?.[1] ?? attrName
+}
+
+/** @public */
+export function hashAttrs (attrs: any): string {
+  const hash = hashIt(attrs)
+  return (hash >>> 0).toString(16).padStart(8, '0')
+}

packages/text-core/src/markup/utils.ts

@@ -42,6 +42,7 @@
   "dependencies": {
     "@hcengineering/core": "^0.6.32",
     "@hcengineering/text": "^0.6.5",
+    "@hcengineering/text-core": "^0.6.0",
     "yjs": "^13.6.27"
   },
   "repository": "https://github.com/hcengineering/platform",