Merge branch 'develop' of https://github.com/hcengineering/platform into staging-new

Signed-off-by: Artem Savchenko <[email protected]>

Author: ArtyomSavchenko

common/config/rush/pnpm-lock.yaml

@@ -1,7 +1,7 @@
 // preload.js
 
 import { contextBridge, ipcRenderer } from 'electron'
-import { BrandingMap, Config, IPCMainExposed, MenuBarAction, NotificationParams, JumpListSpares } from './types'
+import { BrandingMap, Config, IPCMainExposed, JumpListSpares, MenuBarAction, NotificationParams } from './types'
 
 /**
  * @public
@@ -18,27 +18,23 @@ export function concatLink (host: string, path: string): string {
 }
 
 async function loadServerConfig (url: string): Promise<any> {
-  let retries = 5
+  let retries = 1
   let res: Response | undefined
 
-  do {
+  while (true) {
     try {
       res = await fetch(url, {
         keepalive: true
       })
+      if (res === undefined) {
+        // In theory should never get here
+        throw new Error('Failed to load server config')
+      }
       break
     } catch (e) {
-      retries--
-      if (retries === 0) {
-        throw new Error(`Failed to load server config: ${e}`)
-      }
-      await new Promise((resolve) => setTimeout(resolve, 1000 * (5 - retries)))
+      retries++
+      await new Promise((resolve) => setTimeout(resolve, 1000 * Math.min(5, retries)))
     }
-  } while (retries > 0)
-
-  if (res === undefined) {
-    // In theory should never get here
-    throw new Error('Failed to load server config')
   }
 
   return await res.json()

desktop/src/ui/preload.ts

@@ -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",