perf: support close tab by shortcut `Command+W`/`Control+W` (#258)

backend/utils/convert/json_convert.go

@@ -1,9 +1,8 @@
 package convutil
 
 import (
-	"bytes"
-	"encoding/json"
 	"strings"
+	strutil "tinyrdm/backend/utils/string"
 )
 
 type JsonConvert struct{}
@@ -16,18 +15,11 @@ func (JsonConvert) Decode(str string) (string, bool) {
 	trimedStr := strings.TrimSpace(str)
 	if (strings.HasPrefix(trimedStr, "{") && strings.HasSuffix(trimedStr, "}")) ||
 		(strings.HasPrefix(trimedStr, "[") && strings.HasSuffix(trimedStr, "]")) {
-		var out bytes.Buffer
-		if err := json.Indent(&out, []byte(trimedStr), "", "  "); err == nil {
-			return out.String(), true
-		}
+		return strutil.JSONBeautify(trimedStr, "  "), true
 	}
 	return str, false
 }
 
 func (JsonConvert) Encode(str string) (string, bool) {
-	var dst bytes.Buffer
-	if err := json.Compact(&dst, []byte(str)); err != nil {
-		return str, false
-	}
-	return dst.String(), true
+	return strutil.JSONMinify(str), true
 }

backend/utils/convert/unicode_json_convert.go

@@ -2,9 +2,9 @@ package convutil
 
 import (
 	"bytes"
-	"encoding/json"
 	"strconv"
 	"strings"
+	strutil "tinyrdm/backend/utils/string"
 	"unicode"
 	"unicode/utf16"
 	"unicode/utf8"
@@ -20,22 +20,16 @@ func (UnicodeJsonConvert) Decode(str string) (string, bool) {
 	trimedStr := strings.TrimSpace(str)
 	if (strings.HasPrefix(trimedStr, "{") && strings.HasSuffix(trimedStr, "}")) ||
 		(strings.HasPrefix(trimedStr, "[") && strings.HasSuffix(trimedStr, "]")) {
-		var out bytes.Buffer
-		if err := json.Indent(&out, []byte(trimedStr), "", "  "); err == nil {
-			if quoteStr, ok := UnquoteUnicodeJson(out.Bytes()); ok {
+		resultStr := strutil.JSONBeautify(trimedStr, "  ")
+		if quoteStr, ok := UnquoteUnicodeJson([]byte(resultStr)); ok {
 			return string(quoteStr), true
 		}
 	}
-	}
 	return str, false
 }
 
 func (UnicodeJsonConvert) Encode(str string) (string, bool) {
-	var dst bytes.Buffer
-	if err := json.Compact(&dst, []byte(str)); err != nil {
-		return str, false
-	}
-	return dst.String(), true
+	return strutil.JSONMinify(str), true
 }
 
 func UnquoteUnicodeJson(s []byte) ([]byte, bool) {

backend/utils/string/json_formatter.go

@@ -0,0 +1,158 @@
+package strutil
+
+import (
+	"strings"
+	"unicode"
+)
+
+// Convert from https://github.com/ObuchiYuki/SwiftJSONFormatter
+
+// ArrayIterator defines the iterator for an array
+type ArrayIterator[T any] struct {
+	array []T
+	head  int
+}
+
+// NewArrayIterator initializes a new ArrayIterator with the given array
+func NewArrayIterator[T any](array []T) *ArrayIterator[T] {
+	return &ArrayIterator[T]{
+		array: array,
+		head:  -1,
+	}
+}
+
+// HasNext returns true if there are more elements to iterate over
+func (it *ArrayIterator[T]) HasNext() bool {
+	return it.head+1 < len(it.array)
+}
+
+// PeekNext returns the next element without advancing the iterator
+func (it *ArrayIterator[T]) PeekNext() *T {
+	if it.head+1 < len(it.array) {
+		return &it.array[it.head+1]
+	}
+	return nil
+}
+
+// Next returns the next element and advances the iterator
+func (it *ArrayIterator[T]) Next() *T {
+	defer func() {
+		it.head++
+	}()
+	return it.PeekNext()
+}
+
+// JSONBeautify formats a JSON string with indentation
+func JSONBeautify(value string, indent string) string {
+	if len(indent) <= 0 {
+		indent = "    "
+	}
+	return format(value, indent, "\n", " ")
+}
+
+// JSONMinify formats a JSON string by removing all unnecessary whitespace
+func JSONMinify(value string) string {
+	return format(value, "", "", "")
+}
+
+// format applies the specified formatting to a JSON string
+func format(value string, indent string, newLine string, separator string) string {
+	var formatted strings.Builder
+	chars := NewArrayIterator([]rune(value))
+	indentLevel := 0
+
+	for chars.HasNext() {
+		if char := chars.Next(); char != nil {
+			switch *char {
+			case '{', '[':
+				formatted.WriteRune(*char)
+				consumeWhitespaces(chars)
+				peeked := chars.PeekNext()
+				if peeked != nil && (*peeked == '}' || *peeked == ']') {
+					chars.Next()
+					formatted.WriteRune(*peeked)
+				} else {
+					indentLevel++
+					formatted.WriteString(newLine)
+					formatted.WriteString(strings.Repeat(indent, indentLevel))
+				}
+			case '}', ']':
+				indentLevel--
+				formatted.WriteString(newLine)
+				formatted.WriteString(strings.Repeat(indent, max(0, indentLevel)))
+				formatted.WriteRune(*char)
+			case '"':
+				str := consumeString(chars)
+				//str = convertUnicodeString(str)
+				formatted.WriteString(str)
+			case ',':
+				consumeWhitespaces(chars)
+				formatted.WriteRune(',')
+				peeked := chars.PeekNext()
+				if peeked != nil && *peeked != '}' && *peeked != ']' {
+					formatted.WriteString(newLine)
+					formatted.WriteString(strings.Repeat(indent, max(0, indentLevel)))
+				}
+			case ':':
+				formatted.WriteString(":" + separator)
+			default:
+				if !unicode.IsSpace(*char) {
+					formatted.WriteRune(*char)
+				}
+			}
+		}
+	}
+
+	return formatted.String()
+}
+
+// consumeWhitespaces advances the iterator past any whitespace characters
+func consumeWhitespaces(iter *ArrayIterator[rune]) {
+	for iter.HasNext() {
+		if peeked := iter.PeekNext(); peeked != nil && unicode.IsSpace(*peeked) {
+			iter.Next()
+		} else {
+			break
+		}
+	}
+}
+
+// consumeString consumes a JSON string value from the iterator
+func consumeString(iter *ArrayIterator[rune]) string {
+	var sb strings.Builder
+	sb.WriteRune('"')
+	escaping := false
+
+	for iter.HasNext() {
+		if char := iter.Next(); char != nil {
+			if *char == '\n' {
+				return sb.String() // Unterminated string
+			}
+
+			sb.WriteRune(*char)
+
+			if escaping {
+				escaping = false
+			} else {
+				if *char == '\\' {
+					escaping = true
+				}
+				if *char == '"' {
+					break
+				}
+			}
+		}
+	}
+
+	return sb.String()
+}
+
+func convertUnicodeString(str string) string {
+	// TODO: quote UTF-16 characters
+	//if len(str) > 2 {
+	//	if unqStr, err := strconv.Unquote(str); err == nil {
+	//		return strconv.Quote(unqStr)
+	//	}
+	//}
+	return str
+}

frontend/src/AppContent.vue

@@ -110,12 +110,27 @@ onMounted(async () => {
     const maximised = await WindowIsMaximised()
     onToggleMaximize(maximised)
 })
+
+const onKeyShortcut = (e) => {
+    switch (e.key) {
+        case 'w':
+            if (e.metaKey) {
+                // close current tab
+                const tabStore = useTabStore()
+                const currentTab = tabStore.currentTab
+                if (currentTab != null) {
+                    tabStore.closeTab(currentTab.name)
+                }
+            }
+            break
+    }
+}
 </script>
 
 <template>
     <!-- app content-->
     <n-spin :show="props.loading" :style="spinStyle" :theme-overrides="{ opacitySpinning: 0 }">
-        <div id="app-content-wrapper" :style="wrapperStyle" class="flex-box-v">
+        <div id="app-content-wrapper" :style="wrapperStyle" class="flex-box-v" tabindex="0" @keydown="onKeyShortcut">
             <!-- title bar -->
             <div
                 id="app-toolbar"

frontend/src/components/content/ContentValueTab.vue

@@ -2,32 +2,24 @@
 import Server from '@/components/icons/Server.vue'
 import useTabStore from 'stores/tab.js'
 import { computed } from 'vue'
-import { useI18n } from 'vue-i18n'
 import { get, map } from 'lodash'
 import { useThemeVars } from 'naive-ui'
 import useConnectionStore from 'stores/connections.js'
 import { extraTheme } from '@/utils/extra_theme.js'
 import usePreferencesStore from 'stores/preferences.js'
-import useBrowserStore from 'stores/browser.js'
 
 /**
  * Value content tab on head
  */
 
 const themeVars = useThemeVars()
-const i18n = useI18n()
 const tabStore = useTabStore()
 const connectionStore = useConnectionStore()
-const browserStore = useBrowserStore()
 const prefStore = usePreferencesStore()
 
 const onCloseTab = (tabIndex) => {
     const tab = get(tabStore.tabs, tabIndex)
-    if (tab != null) {
-        $dialog.warning(i18n.t('dialogue.close_confirm', { name: tab.name }), () => {
-            browserStore.closeConnection(tab.name)
-        })
-    }
+    tabStore.closeTab(tab.name)
 }
 
 const tabMarkColor = computed(() => {

frontend/src/components/content_value/ContentServerStatus.vue

@@ -80,9 +80,11 @@ const refreshInfo = async (force) => {
     }
     if (!isEmpty(props.server) && browserStore.isConnected(props.server)) {
         try {
-            const info = await browserStore.getServerInfo(props.server)
+            const info = await browserStore.getServerInfo(props.server, true)
+            if (!isEmpty(info)) {
                 serverInfo.value = info
                 _updateChart(info)
+            }
         } finally {
             pageState.loading = false
             pageState.autoLoading = false

frontend/src/stores/browser.js

@@ -343,10 +343,11 @@ const useBrowserStore = defineStore('browser', {
 
         /**
          *
-         * @param server
+         * @param {string} server
+         * @param {boolean} mute
          * @returns {Promise<{}>}
          */
-        async getServerInfo(server) {
+        async getServerInfo(server, mute) {
             try {
                 const { success, data, msg } = await ServerInfo(server)
                 if (success) {
@@ -356,7 +357,7 @@ const useBrowserStore = defineStore('browser', {
                         serverInst.stats = data
                     }
                     return data
-                } else if (!isEmpty(msg)) {
+                } else if (!isEmpty(msg) && mute !== true) {
                     $message.warning(msg)
                 }
             } finally {

frontend/src/stores/tab.js

@@ -1,6 +1,8 @@
 import { assign, find, findIndex, get, includes, indexOf, isEmpty, pullAt, remove, set, size } from 'lodash'
 import { defineStore } from 'pinia'
 import { TabItem } from '@/objects/tabItem.js'
+import useBrowserStore from 'stores/browser.js'
+import { i18nGlobal } from '@/utils/i18n.js'
 
 const useTabStore = defineStore('tab', {
     /**
@@ -132,6 +134,17 @@ const useTabStore = defineStore('tab', {
             this.upsertTab({ server, clearValue: true })
         },
 
+        /**
+         *
+         * @param {string} tabName
+         */
+        closeTab(tabName) {
+            $dialog.warning(i18nGlobal.t('dialogue.close_confirm', { name: tabName }), () => {
+                const browserStore = useBrowserStore()
+                browserStore.closeConnection(tabName)
+            })
+        },
+
         /**
          * update or insert a new tab if not exists with the same name
          * @param {string} subTab