Upload CantonesePhonetics.js

CantonesePhonetics.js

@@ -0,0 +1,186 @@
+    class CantonesePhonetics {
+      constructor() {
+        this.charToJyutping = {};
+        this.savedResults = [];
+        this.similarInitials = {
+          b: ["p", "m"],
+          c: ["z", "s"],
+          d: ["t", "n"],
+          f: ["h", "w"],
+          g: ["k", "ng"],
+          gw: ["kw"],
+          h: ["f", "w"],
+          j: ["z", "c"],
+          k: ["g", "h"],
+          kw: ["gw"],
+          l: ["n"],
+          m: ["n", "b"],
+          n: ["l", "m", "ng"],
+          ng: ["g", "n"],
+          p: ["b", "m"],
+          s: ["c", "z"],
+          t: ["d", "n"],
+          w: ["f", "h"],
+          z: ["c", "j"]
+        };
+        this.similarFinals = {
+          aa: ["a", "aai", "aau"],
+          aai: ["aa", "ai"],
+          aau: ["aa", "au"],
+          ai: ["ei", "aai"],
+          au: ["ou", "aau"],
+          e: ["i", "ei"],
+          ei: ["ai", "i"],
+          i: ["e", "ei", "yu"],
+          o: ["u", "ou"],
+          oi: ["ui"],
+          ou: ["u", "au"],
+          u: ["o", "ou", "yu"],
+          ui: ["oi"],
+          yu: ["i", "u"]
+        };
+      }
+
+      async initialize() {
+        const [jyutpingData, results] = await Promise.all([
+          fetch("https://huggingface.co/spaces/OttoYu/Cantonese-Phonetics/raw/main/lexi-can_key.json").then(response => response.json()),
+          fetch("https://huggingface.co/spaces/OttoYu/Cantonese-Phonetics/raw/main/jyutping_results_largec.json").then(response => response.json())
+        ]);
+
+        this.charToJyutping = this.preprocessJyutpingData(jyutpingData);
+        this.savedResults = results;
+      }
+
+      preprocessJyutpingData(jyutpingData) {
+        const result = {};
+        for (const [syllable, mappings] of Object.entries(jyutpingData)) {
+          for (const mapping of mappings) {
+            for (const char of mapping["漢字"]) {
+              result[char] = syllable;
+            }
+          }
+        }
+        return result;
+      }
+
+      chineseToJyutping(text) {
+        return text.split("").map(char => this.charToJyutping[char] || char);
+      }
+
+      areJyutpingSimilar(jyutping1, jyutping2) {
+        function splitJyutping(jyutping) {
+          if (jyutping.length > 1 && "wzjgk".includes(jyutping[1])) {
+            return [jyutping.slice(0, 2), jyutping.slice(2)];
+          }
+          return [jyutping[0], jyutping.slice(1)];
+        }
+
+        const [initial1, final1] = splitJyutping(jyutping1);
+        const [initial2, final2] = splitJyutping(jyutping2);
+
+        const initialMatch = initial1 === initial2 ||
+          (this.similarInitials[initial1] && this.similarInitials[initial1].includes(initial2)) ||
+          (this.similarInitials[initial2] && this.similarInitials[initial2].includes(initial1));
+
+        const finalMatch = final1 === final2 ||
+          (this.similarFinals[final1] && this.similarFinals[final1].includes(final2)) ||
+          (this.similarFinals[final2] && this.similarFinals[final2].includes(final1));
+
+        return initialMatch && finalMatch;
+      }
+
+      calculatePhoneticSimilarity(userJyutping, resultJyutping) {
+        const similarCount = userJyutping.reduce(
+          (count, uj) => count + resultJyutping.filter(rj => this.areJyutpingSimilar(uj, rj)).length,
+          0
+        );
+        return similarCount / Math.max(userJyutping.length, resultJyutping.length);
+      }
+
+      similarity(s1, s2) {
+        let longer = s1,
+          shorter = s2;
+        if (s1.length < s2.length) {
+          longer = s2;
+          shorter = s1;
+        }
+        const longerLength = longer.length;
+        if (longerLength == 0) {
+          return 1.0;
+        }
+        return (longerLength - this.editDistance(longer, shorter)) / longerLength;
+      }
+
+      editDistance(s1, s2) {
+        s1 = s1.toLowerCase();
+        s2 = s2.toLowerCase();
+
+        const costs = new Array();
+        for (let i = 0; i <= s1.length; i++) {
+          let lastValue = i;
+          for (let j = 0; j <= s2.length; j++) {
+            if (i == 0) costs[j] = j;
+            else {
+              if (j > 0) {
+                let newValue = costs[j - 1];
+                if (s1.charAt(i - 1) != s2.charAt(j - 1))
+                  newValue = Math.min(Math.min(newValue, lastValue), costs[j]) + 1;
+                costs[j - 1] = lastValue;
+                lastValue = newValue;
+              }
+            }
+          }
+          if (i > 0) costs[s2.length] = lastValue;
+        }
+        return costs[s2.length];
+      }
+
+      matchUserInput(userInput) {
+        const userJyutping = this.chineseToJyutping(userInput);
+
+        const exactMatch = this.savedResults.find(result =>
+          userJyutping.every(uj => result.jyutping.includes(uj))
+        );
+
+        if (exactMatch) {
+          return {
+            input_text: userInput,
+            input_jyutping: userJyutping,
+            match: exactMatch,
+            match_type: "exact"
+          };
+        }
+
+        const matches = this.savedResults
+          .map(result => {
+            if (!result.text || !result.jyutping) return null;
+
+            const phoneticScore = this.calculatePhoneticSimilarity(userJyutping, result.jyutping);
+            const textSimilarity = this.similarity(userInput, result.text);
+            const lengthDiff = Math.abs(userInput.length - result.text.length);
+            const lengthPenalty = 1 / (1 + lengthDiff);
+
+            const totalScore = phoneticScore * 0.7 + textSimilarity * 0.2 + lengthPenalty * 0.1;
+            return {
+              result,
+              score: totalScore
+            };
+          })
+          .filter(Boolean);
+
+        matches.sort((a, b) => b.score - a.score);
+        const topMatches = matches.slice(0, 3);
+
+        return {
+          input_text: userInput,
+          input_jyutping: userJyutping,
+          matches: topMatches.map(match => ({
+            match: match.result,
+            score: match.score,
+            match_type: "phonetic_similarity"
+          }))
+        };
+      }
+    }
+
+    const phonetics = new CantonesePhonetics();