fix(all): debug

src/hooks/article.ts

@@ -310,3 +310,4 @@ export function getSplitTranslateText(article: string) {
   }
   return str
 }
+

src/hooks/event.ts

@@ -1,5 +1,6 @@
 import {onMounted, onUnmounted} from "vue";
 import {emitter, EventKey} from "@/utils/eventBus.ts";
+import {useRuntimeStore} from "@/stores/runtime.ts";
 
 export function useWindowClick(cb: () => void) {
     onMounted(() => {
@@ -16,13 +17,49 @@ export function useEventListener(type: string, listener: EventListenerOrEventLis
     onUnmounted(() => window.removeEventListener(type, listener))
 }
 
-export function useEsc(can: boolean) {
+export function useStartKeyboardEventListener() {
+    const runtimeStore = useRuntimeStore()
+
+    useEventListener('keydown', (e: KeyboardEvent) => {
+        if (!runtimeStore.disableEventListener) {
+            emitter.emit(EventKey.keydown, e)
+        }
+    })
+    useEventListener('keyup', (e: KeyboardEvent) => {
+        if (!runtimeStore.disableEventListener) {
+            emitter.emit(EventKey.keyup, e)
+        }
+    })
+}
+
+export function useOnKeyboardEventListener(onKeyDown: (e: KeyboardEvent) => void, onKeyUp: (e: KeyboardEvent) => void) {
+    onMounted(() => {
+        emitter.on(EventKey.keydown, onKeyDown)
+        emitter.on(EventKey.keyup, onKeyUp)
+    })
+    onUnmounted(() => {
+        emitter.off(EventKey.keydown, onKeyDown)
+        emitter.off(EventKey.keyup, onKeyUp)
+    })
+}
+
+export function useDisableEventListener() {
+    const runtimeStore = useRuntimeStore()
+    onMounted(() => {
+        runtimeStore.disableEventListener = true
+    })
+    onUnmounted(() => {
+        runtimeStore.disableEventListener = false
+    })
+}
+
+export function useEsc(close: () => void) {
     onMounted(() => {
         window.addEventListener('keyup', (e: KeyboardEvent) => {
-            if (e.key === 'Escape' && can) {
+            if (e.key === 'Escape') {
                 close()
             }
         })
     })
-    return []
-}
+}
+

src/hooks/translate.ts

@@ -1,53 +1,52 @@
-import {Article, Sentence, TranslateEngine} from "@/types.ts";
+import {Article, Sentence, TranslateEngine, TranslateType} from "@/types.ts";
 import Baidu from "@opentranslate/baidu";
 import {axiosInstance} from "@/utils/http.ts";
-import {CnKeyboardMap, EnKeyboardMap, splitCNArticle} from "@/hooks/article.ts";
+import {getSplitTranslateText, splitArticle} from "@/hooks/article.ts";
 import {Translator} from "@opentranslate/translator/src/translator.ts";
-import {cloneDeep} from "lodash-es";
 
 export function updateLocalSentenceTranslate(article: Article, translate: string) {
-  if (translate.trim()) {
-    let articleTranslate = translate.split('\n')
-    // console.log('articleTranslate', articleTranslate)
-    let count = 0
-    for (let i = 0; i < article.sections.length; i++) {
-      let v = article.sections[i]
-      for (let j = 0; j < v.length; j++) {
-        let sentence = v[j]
-        try {
-          sentence.translate = articleTranslate[count]
-        } catch (e) {
-          console.log('没有对应的翻译', sentence.text)
+    if (translate.trim()) {
+        let articleTranslate = translate.split('\n')
+        // console.log('articleTranslate', articleTranslate)
+        let count = 0
+        for (let i = 0; i < article.sections.length; i++) {
+            let v = article.sections[i]
+            for (let j = 0; j < v.length; j++) {
+                let sentence = v[j]
+                try {
+                    sentence.translate = articleTranslate[count]
+                } catch (e) {
+                    console.log('没有对应的翻译', sentence.text)
+                }
+                count++
+            }
+            count++
         }
-        count++
-      }
-      count++
     }
-  }
 }
 
 export function getSentenceAllTranslateText(article: Article) {
-  let str = ''
-  article.sections.map((v: Sentence[]) => {
-    v.map((w: Sentence, j, arr) => {
-      if (w.translate) {
-        str += w.translate + '\n'
-      }
+    let str = ''
+    article.sections.map((v: Sentence[]) => {
+        v.map((w: Sentence, j, arr) => {
+            if (w.translate) {
+                str += w.translate + '\n'
+            }
+        })
+        str += '\n'
     })
-    str += '\n'
-  })
-  return str
+    return str
 }
 
 export function getSentenceAllText(article: Article) {
-  let str = ''
-  article.sections.map((v: Sentence[]) => {
-    v.map((w: Sentence, j, arr) => {
-      str += w.text
+    let str = ''
+    article.sections.map((v: Sentence[]) => {
+        v.map((w: Sentence, j, arr) => {
+            str += w.text
+        })
+        str += '\n'
     })
-    str += '\n'
-  })
-  return str
+    return str
 }
 
 /***
@@ -58,135 +57,162 @@ export function getSentenceAllText(article: Article) {
  * @param progressCb 进度回调
  * */
 export async function getNetworkTranslate(
-  article: Article,
-  translateEngine: TranslateEngine,
-  allShow: boolean = false,
-  progressCb?: (val: number) => void
+    article: Article,
+    translateEngine: TranslateEngine,
+    allShow: boolean = false,
+    progressCb?: (val: number) => void
 ) {
-  if (article.networkTranslate) {
-    updateLocalSentenceTranslate(article, article.networkTranslate)
-  } else {
-    let translator: Translator
-    if (translateEngine === TranslateEngine.Baidu) {
-      translator = new Baidu({
-        axios: axiosInstance as any,
-        config: {
-          appid: "20230910001811857",
-          key: "Xxe_yftQR3K3Ue43NQMC"
+    if (article.networkTranslate) {
+        updateLocalSentenceTranslate(article, article.networkTranslate)
+    } else {
+        let translator: Translator
+        if (translateEngine === TranslateEngine.Baidu) {
+            translator = new Baidu({
+                axios: axiosInstance as any,
+                config: {
+                    appid: "20230910001811857",
+                    key: "Xxe_yftQR3K3Ue43NQMC"
+                }
+            }) as any
+        }
+
+
+        if (translator) {
+            if (!article.titleTranslate) {
+                translator.translate(article.title, 'en', 'zh-CN').then(r => {
+                    article.titleTranslate = r.trans.paragraphs[0]
+                })
+            }
+
+            let promiseList = []
+            let retryCount = 0
+            let retryCountMap = new Map()
+
+            const translate = async (sentence: Sentence) => {
+                try {
+                    let r = await translator.translate(sentence.text, 'en', 'zh-CN')
+                    if (r) {
+                        const cb = () => {
+                            sentence.translate = r.trans.paragraphs[0]
+                            if (!allShow) {
+                                //一次显示所有，顺序会乱
+                                article.networkTranslate += sentence.translate + '\n'
+                            }
+                        }
+                        return Promise.resolve(cb)
+                    } else {
+                        return Promise.reject(() => translate(sentence))
+                    }
+                } catch (e) {
+                    return Promise.reject(() => translate(sentence))
+                }
+            }
+
+            let total = 0
+            let index = 0
+            article.sections.map(v => total += v.length)
+
+            for (let i = 0; i < article.sections.length; i++) {
+                let v = article.sections[i]
+                for (let j = 0; j < v.length; j++) {
+                    let sentence = v[j]
+                    let promise = translate(sentence)
+                    if (allShow) {
+                        promiseList.push(promise)
+                    } else {
+                        retryCountMap.set(sentence.text, 0)
+                        let errResult: any
+                        let cb = await promise.catch(err => {
+                            errResult = err
+                        })
+
+                        while (errResult) {
+                            let count = retryCountMap.get(sentence.text)
+                            if (count > 2) break
+                            cb = await errResult().catch(err => {
+                                errResult = err
+                            })
+                            retryCountMap.set(sentence.text, count + 1)
+                        }
+                        if (cb) cb()
+                        index++
+                        if (progressCb) {
+                            progressCb(Math.floor((index / total) * 100))
+                        }
+                    }
+                }
+            }
+
+            if (promiseList.length) {
+                let timer = -1
+                let progress = 0
+                if (progressCb) {
+                    timer = setInterval(() => {
+                        progress++
+                        if (progress > 90) {
+                            return clearInterval(timer)
+                        }
+                        progressCb(progress)
+                    }, 100)
+                }
+
+                return new Promise(async resolve => {
+                    let cbs = []
+                    do {
+                        if (retryCount > 2) {
+                            return resolve(true)
+                        }
+                        let results = await Promise.allSettled(promiseList)
+                        promiseList = []
+                        results.map(results => {
+                            if (results.status === 'fulfilled') {
+                                cbs.push(results.value)
+                            } else {
+                                promiseList.push(results.reason())
+                            }
+                        })
+                        retryCount++
+                    } while (promiseList.length)
+                    cbs.map(v => v())
+                    article.networkTranslate = getSentenceAllTranslateText(article)
+
+                    if (progressCb) {
+                        clearInterval(timer)
+                        progress = 100
+                        progressCb(100)
+                    }
+                    resolve(true)
+                })
+            } else {
+                article.networkTranslate = getSentenceAllTranslateText(article)
+            }
         }
-      }) as any
     }
+}
 
+export function test(article: Article) {
+    if (article?.isTranslated) {
+        if (!article.sections?.length) {
 
-    if (translator) {
-      if (!article.titleTranslate) {
-        translator.translate(article.title, 'en', 'zh-CN').then(r => {
-          article.titleTranslate = r.trans.paragraphs[0]
-        })
-      }
-
-      let promiseList = []
-      let retryCount = 0
-      let retryCountMap = new Map()
-
-      const translate = async (sentence: Sentence) => {
-        try {
-          let r = await translator.translate(sentence.text, 'en', 'zh-CN')
-          if (r) {
-            const cb = () => {
-              sentence.translate = r.trans.paragraphs[0]
-              if (!allShow) {
-                //一次显示所有，顺序会乱
-                article.networkTranslate += sentence.translate + '\n'
-              }
-            }
-            return Promise.resolve(cb)
-          } else {
-            return Promise.reject(() => translate(sentence))
-          }
-        } catch (e) {
-          return Promise.reject(() => translate(sentence))
         }
-      }
-
-      let total = 0
-      let index = 0
-      article.sections.map(v => total += v.length)
-
-      for (let i = 0; i < article.sections.length; i++) {
-        let v = article.sections[i]
-        for (let j = 0; j < v.length; j++) {
-          let sentence = v[j]
-          let promise = translate(sentence)
-          if (allShow) {
-            promiseList.push(promise)
-          } else {
-            retryCountMap.set(sentence.text, 0)
-            let errResult: any
-            let cb = await promise.catch(err => {
-              errResult = err
-            })
-
-            while (errResult) {
-              let count = retryCountMap.get(sentence.text)
-              if (count > 2) break
-              cb = await errResult().catch(err => {
-                errResult = err
-              })
-              retryCountMap.set(sentence.text, count + 1)
+    } else {
+        if (article.translateType !== undefined) {
+            if (article.translateType) {
+                updateLocalSentenceTranslate(article, article.customTranslate)
+            } else {
+                updateLocalSentenceTranslate(article, article.networkTranslate)
             }
-            if (cb) cb()
-            index++
-            if (progressCb) {
-              progressCb(Math.floor((index / total) * 100))
+        } else {
+            article.sections = splitArticle(article.article)
+            if (article.customTranslate) {
+                article.customTranslate = getSplitTranslateText(article.customTranslate)
+                updateLocalSentenceTranslate(article, article.customTranslate)
+                article.translateType = TranslateType.custom
+            } else {
+                article.networkTranslate = getSplitTranslateText(article.networkTranslate)
+                updateLocalSentenceTranslate(article, article.customTranslate)
+                article.translateType = TranslateType.network
             }
-          }
         }
-      }
-
-      if (promiseList.length) {
-        let timer = -1
-        let progress = 0
-        if (progressCb) {
-          timer = setInterval(() => {
-            progress++
-            if (progress > 90) {
-              return clearInterval(timer)
-            }
-            progressCb(progress)
-          }, 100)
-        }
-
-        return new Promise(async resolve => {
-          let cbs = []
-          do {
-            if (retryCount > 2) {
-              return resolve(true)
-            }
-            let results = await Promise.allSettled(promiseList)
-            promiseList = []
-            results.map(results => {
-              if (results.status === 'fulfilled') {
-                cbs.push(results.value)
-              } else {
-                promiseList.push(results.reason())
-              }
-            })
-            retryCount++
-          } while (promiseList.length)
-          cbs.map(v => v())
-          article.networkTranslate = getSentenceAllTranslateText(article)
-
-          if (progressCb) {
-            clearInterval(timer)
-            progress = 100
-            progressCb(100)
-          }
-          resolve(true)
-        })
-      } else {
-        article.networkTranslate = getSentenceAllTranslateText(article)
-      }
     }
-  }
 }