feat: FluPinyin增加拼音缓存机制

Author: Polaris-Night

example/qml/page/T_Pinyin.qml

@@ -120,7 +120,7 @@ FluScrollablePage {
         title: "segment"
         ColumnLayout {
             FluText {
-                text: 'FluPinyin.segment("小明硕士毕业于中国科学院计算所，后在日本京都大学深造") --> \n%1'.arg(JSON.stringify(FluPinyin.segment("小明硕士毕业于中国科学院计算所，后在日本京都大学深造"), null, 2))
+                text: 'FluPinyin.segment("小明硕士毕业于中国科学院计算所") --> \n%1'.arg(JSON.stringify(FluPinyin.segment("小明硕士毕业于中国科学院计算所，后在日本京都大学深造"), null, 2))
             }
         }
     }

src/Qt5/imports/FluentUI/Controls/FluPinyin.qml

@@ -6,25 +6,24 @@ import "./../JS/PinyinPro.mjs" as Pinyin
 QtObject {
     property list<QtObject> children
     readonly property var context: Pinyin
-    property int patternValue: 500 // In "size" mode, number of patterns per build; in "group" mode, number of groups to divide patterns into
     property string patternBuildMode: "size" // size, group
-    property alias patternBuildInterval: patternTimer.interval
+    property int patternValue: 500 // In "size" mode, number of patterns per build; in "group" mode, number of groups to divide patterns into
+    property int patternBuildInterval: 1500
     readonly property alias isPatternBuilt: d.isPatternBuilt
     readonly property var outputFormat: Pinyin.OutputFormat
     function buildPattern(buildAllAtOnce = true) {
-        if (d.isPatternBuilt || patternTimer.running) {
+        const builder = context.getPatternsNormalBuilder(patternValue,
+                                                         patternBuildMode)
+        if (!builder || d.isPatternBuilt || (d.patternTimer && d.patternTimer.running)) {
             return
         }
-        d.builder = context.getPatternsNormalBuilder(patternValue,
-                                                     patternBuildMode)
         if (buildAllAtOnce) {
-            while (!d.buildNext()) {
+            while (!builder.next().done) {
 
             }
-            d.builder = null
             d.isPatternBuilt = true
         } else {
-            patternTimer.start()
+            d.patternTimer = d.stepRunner(builder, () => d.isPatternBuilt = true, patternBuildInterval)
         }
     }
     function addDict(dict, options) {
@@ -54,26 +53,54 @@ QtObject {
     function segment(word, options) {
         return context.segment(word, options)
     }
+    function createCache(data, options, buildCache = true) {
+        return context.createCache(data, options, buildCache)
+    }
+    function rebuildCache(cache, data, asyncArg) {
+        cache.data = data
+        const arg = Object.assign({
+                                      "async": true,
+                                      "chunkSize": 50,
+                                      "interval": 500,
+                                      "triggeredOnStart": true
+                                  }, asyncArg || {})
+        if (arg.async) {
+            const timer = d.stepRunner(cache.buildGenerator(arg.chunkSize, true, arg.interval, arg.triggeredOnStart))
+            if (cache.data.length > arg.chunkSize) {
+                cache.generatorDeleter = timer.destroy
+            }
+        } else {
+            cache.build(true)
+        }
+    }
+    function findMatches(cache, pinyin) {
+        return context.findMatches(cache, pinyin)
+    }
     children: [
         QtObject {
             id: d
+            property Timer patternTimer: null
             property bool isPatternBuilt: false
-            property var builder: null
-            function buildNext() {
-                return d.builder.next().done
-            }
-        },
-        Timer {
-            id: patternTimer
-            interval: 1500
-            repeat: true
-            triggeredOnStart: true
-            onTriggered: {
-                if (d.buildNext()) {
-                    d.builder = null
-                    d.isPatternBuilt = true
-                    stop()
+            function stepRunner(generator, doneCallback, interval = 500, triggeredOnStart = true) {
+                const timer = Qt.createQmlObject("import QtQuick 2.15; Timer {}", Qt.application)
+                timer.interval = interval
+                timer.triggered.connect(function () {
+                    const result = generator.next()
+                    if (result.done) {
+                        timer.destroy()
+                        if (typeof doneCallback === "function") {
+                            doneCallback()
+                        }
+                    } else {
+                        timer.start()
+                    }
+                })
+                timer.Component.onDestruction.connect(() => generator = null)
+                if (triggeredOnStart) {
+                    generator.next()
                 }
+                timer.start()
+                return timer
             }
         }
     ]