henkan 0.1.2 → 0.2.0

package/dist/index.cjs.js

@@ -1214,6 +1214,13 @@ function convertJMdict(xmlString, examples) {
     const dict = [];
     import_xml2js.default.parseString(dictParsed, (err, result) => {
       if (err) throw err;
+      let tanakaBaseParts = void 0;
+      if (examples)
+        tanakaBaseParts = new Set(
+          examples.map(
+            (example) => example.parts.map((part) => part.baseForm)
+          ).flat()
+        );
       if (result.JMdict && typeof result.JMdict === "object" && isValidArray(result.JMdict.entry))
         for (const entry of result.JMdict.entry) {
           const entryObj = {
@@ -1309,21 +1316,19 @@ function convertJMdict(xmlString, examples) {
             ) : void 0;
             let kanjiFormExamples = false;
             let readingExamples = false;
-            if (kanjiForms2) {
-              outer: for (const example of examples)
-                for (const part of example.parts)
-                  if (kanjiForms2.has(part.baseForm)) {
-                    kanjiFormExamples = true;
-                    break outer;
-                  }
+            if (kanjiForms2 && kanjiForms2.size > 0 && tanakaBaseParts) {
+              for (const kf of kanjiForms2)
+                if (tanakaBaseParts.has(kf)) {
+                  kanjiFormExamples = true;
+                  break;
+                }
             }
-            if (!kanjiFormExamples) {
-              outer: for (const example of examples)
-                for (const part of example.parts)
-                  if (readings2.has(part.baseForm)) {
-                    readingExamples = true;
-                    break outer;
-                  }
+            if (!kanjiFormExamples && readings2.size > 0 && tanakaBaseParts) {
+              for (const r of readings2)
+                if (tanakaBaseParts.has(r)) {
+                  readingExamples = true;
+                  break;
+                }
             }
             if (kanjiFormExamples || readingExamples)
               entryObj.hasPhrases = true;
@@ -1392,8 +1397,11 @@ function convertKanjiDic(xmlString) {
                   }
                   if (isValidArray(group.meaning)) {
                     for (const meaning of group.meaning)
-                      if (typeof meaning === "string")
+                      if (typeof meaning === "string") {
+                        if (kanjiObj.isKokuji === void 0 && meaning === "(kokuji)")
+                          kanjiObj.isKokuji = true;
                         groupObj.meanings.push(meaning);
+                      }
                   }
                   if (groupObj.readings.length > 0 || groupObj.meanings.length > 0)
                     rmObj.groups.push(groupObj);
@@ -1575,11 +1583,12 @@ function lookupWordNote(key, notes, tags, required, fallback) {
   );
   if (!info) {
     if (required) throw new Error(`Invalid note info for ${key}`);
-    notes.push(fallback != null ? fallback : key);
-    return;
+    if (notes) notes.push(fallback != null ? fallback : key);
+    return { note: fallback != null ? fallback : key };
   }
-  tags.push(info[0]);
-  notes.push(info[1]);
+  if (tags) tags.push(`word::${info[0]}`);
+  if (notes) notes.push(info[1]);
+  return { note: info[1], tag: `word::${info[0]}` };
 }
 var wordAddNoteArray = (arr, cb) => {
   if (!arr) return;
@@ -1596,40 +1605,50 @@ function getWord(dict, id, kanjiDic, examples, dictWord, noteTypeName, deckPath)
         translations: [],
         noteID: `word_${dictWord.id}`,
         ...noteTypeName ? { noteTypeName } : {},
-        ...deckPath ? { deckPath } : {}
+        ...deckPath ? { deckPath } : {},
+        tags: []
       };
+      if (dictWord.isCommon === true) word.common = true;
       if (dictWord.kanjiForms)
         word.kanjiForms = dictWord.kanjiForms.map(
-          (dictKanjiForm) => {
-            if (dictKanjiForm.commonness && dictKanjiForm.commonness.length > 0 && word.common === void 0)
-              word.common = true;
-            return {
-              kanjiForm: dictKanjiForm.form,
-              ...dictKanjiForm.notes ? {
-                notes: dictKanjiForm.notes.map(
-                  (note) => capitalizeString(note)
-                )
-              } : {}
-            };
-          }
+          (dictKanjiForm) => ({
+            kanjiForm: dictKanjiForm.form,
+            ...dictKanjiForm.notes ? {
+              notes: dictKanjiForm.notes.map((note) => {
+                var _a;
+                const noteAndTag = lookupWordNote(
+                  note,
+                  void 0,
+                  word.tags,
+                  false,
+                  note
+                );
+                return capitalizeString((_a = noteAndTag.note) != null ? _a : note);
+              })
+            } : {}
+          })
         );
-      word.readings = dictWord.readings.map((dictReading) => {
-        if (dictReading.commonness && dictReading.commonness.length > 0 && word.common === void 0)
-          word.common = true;
-        return {
-          reading: dictReading.reading,
-          ...dictReading.kanjiFormRestrictions || dictReading.notes ? {
-            notes: [
-              ...dictReading.kanjiFormRestrictions ? dictReading.kanjiFormRestrictions.map(
-                (restriction) => `Reading restricted to ${restriction}`
-              ) : [],
-              ...dictReading.notes ? dictReading.notes.map(
-                (note) => capitalizeString(note)
-              ) : []
-            ]
-          } : {}
-        };
-      });
+      word.readings = dictWord.readings.map((dictReading) => ({
+        reading: dictReading.reading,
+        ...dictReading.kanjiFormRestrictions || dictReading.notes ? {
+          notes: [
+            ...dictReading.kanjiFormRestrictions ? dictReading.kanjiFormRestrictions.map(
+              (restriction) => `Reading restricted to ${restriction}`
+            ) : [],
+            ...dictReading.notes ? dictReading.notes.map((note) => {
+              var _a;
+              const noteAndTag = lookupWordNote(
+                note,
+                void 0,
+                word.tags,
+                false,
+                note
+              );
+              return capitalizeString((_a = noteAndTag.note) != null ? _a : note);
+            }) : []
+          ]
+        } : {}
+      }));
       let usuallyInKanaMeanings = 0;
       word.translations = dictWord.meanings.map((dictMeaning) => {
         if (!dictMeaning.translations)
@@ -1650,7 +1669,6 @@ function getWord(dict, id, kanjiDic, examples, dictWord, noteTypeName, deckPath)
           }
         );
         const notes = [];
-        word.tags = [];
         wordAddNoteArray(
           dictMeaning.kanjiFormRestrictions,
           (restriction) => notes.push(`Meaning restricted to ${restriction}`)
@@ -1721,7 +1739,7 @@ function getWord(dict, id, kanjiDic, examples, dictWord, noteTypeName, deckPath)
           }
         if (word.kanji.length === 0) delete word.kanji;
       }
-      if (examples) {
+      if (examples && dictWord.hasPhrases === true) {
         const readings = new Set(
           word.readings.filter(
             (reading) => !reading.notes || reading.notes && !reading.notes.some(
@@ -1793,6 +1811,7 @@ function getWord(dict, id, kanjiDic, examples, dictWord, noteTypeName, deckPath)
   }
 }
 function getKanji(kanjiChar, dict, jmDict, svgList, noteTypeName, deckPath) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
   try {
     const dictKanji = dict.find(
       (entry) => entry.kanji === kanjiChar
@@ -1907,26 +1926,28 @@ function getKanji(kanjiChar, dict, jmDict, svgList, noteTypeName, deckPath) {
         let codePoint = kanji.kanji.codePointAt(0);
         if (codePoint !== void 0) {
           codePoint = codePoint.toString(16);
+          const fileNames = [
+            `0${codePoint}.svg`,
+            `${codePoint}.svg`
+          ];
           const svg = svgList.find(
-            (svgFile) => svgFile.toLowerCase() === `0${codePoint}.svg` || svgFile.toLowerCase() === `${codePoint}.svg`
+            (svgFile) => fileNames.includes(svgFile.toLowerCase())
           );
           if (svg) kanji.svg = svg;
         }
       }
       kanji.tags = [];
-      if (kanji.meanings && kanji.meanings.some((meaning) => meaning === "(kokuji)")) {
-        kanji.tags.push("kokuji");
-        kanji.meanings = kanji.meanings.filter(
-          (meaning) => meaning !== "(kokuji)"
-        );
+      if (dictKanji.isKokuji === true) {
+        kanji.kokuji = true;
+        kanji.tags.push("kanji::kokuji");
       }
       kanji.tags.push(
-        ...!kanji.onyomi ? ["no::onyomi"] : [],
-        ...!kanji.kunyomi ? ["no::kunyomi"] : [],
-        ...kanji.nanori ? ["has::nanori"] : [],
-        ...kanji.svg ? ["has::svg"] : [],
-        ...kanji.strokes && kanji.strokes.length > 0 ? [`strokes::${kanji.strokes}`] : [],
-        ...kanji.words ? ["has::words"] : []
+        `kanji::onyomi::${(_b = (_a = kanji.onyomi) == null ? void 0 : _a.length) != null ? _b : 0}`,
+        `kanji::kunyomi::${(_d = (_c = kanji.kunyomi) == null ? void 0 : _c.length) != null ? _d : 0}`,
+        `kanji::nanori::${(_f = (_e = kanji.nanori) == null ? void 0 : _e.length) != null ? _f : 0}`,
+        `kanji::strokes::${(_g = kanji.strokes) != null ? _g : "unknown"}`,
+        `kanji::words::${(_i = (_h = kanji.words) == null ? void 0 : _h.length) != null ? _i : 0}`,
+        ...kanji.svg ? ["kanji::has_svg"] : []
       );
       return kanji;
     } else throw new Error(`Kanji ${kanjiChar} not found`);
@@ -1935,6 +1956,7 @@ function getKanji(kanjiChar, dict, jmDict, svgList, noteTypeName, deckPath) {
   }
 }
 function getKanjiExtended(kanjiChar, info, dict, useJpdbWords, jmDict, svgList, noteTypeName, deckPath) {
+  var _a, _b, _c, _d;
   try {
     const kanji = getKanji(
       kanjiChar,
@@ -1950,12 +1972,25 @@ function getKanjiExtended(kanjiChar, info, dict, useJpdbWords, jmDict, svgList,
       kanji.mnemonic = info.mnemonic;
     if (useJpdbWords === true && info.words && info.words.length > 0)
       kanji.words = info.words;
-    if (kanji.mnemonic && kanji.mnemonic.length > 0 && kanji.tags)
-      kanji.tags.push("has::mnemonic");
-    if (kanji.components && kanji.components.length > 0 && kanji.tags)
-      kanji.tags.push(`components::${kanji.components.length}`);
-    if (kanji.words && kanji.tags && !kanji.tags.includes("has::words"))
-      kanji.tags.push("has::words");
+    if (kanji.tags) {
+      kanji.tags.push(`kanji::components::${(_b = (_a = kanji.components) == null ? void 0 : _a.length) != null ? _b : 0}`);
+      if (kanji.mnemonic && kanji.mnemonic.length > 0)
+        kanji.tags.push("kanji::has_mnemonic");
+      if (useJpdbWords === true && kanji.words) {
+        if (!kanji.tags.some((tag, index) => {
+          var _a2, _b2;
+          if (tag.startsWith("kanji::words::")) {
+            kanji.tags.splice(
+              index,
+              1,
+              `kanji::words::${(_b2 = (_a2 = kanji.words) == null ? void 0 : _a2.length) != null ? _b2 : 0}`
+            );
+            return true;
+          } else return false;
+        }))
+          kanji.tags.push(`kanji::words::${(_d = (_c = kanji.words) == null ? void 0 : _c.length) != null ? _d : 0}`);
+      }
+    }
     if (kanji.fromJpdb === true && (kanji.mnemonic || kanji.components && kanji.components.length > 0 || kanji.words))
       kanji.source = `https://jpdb.io/kanji/${kanji.kanji}#a`;
     return kanji;
@@ -2160,12 +2195,12 @@ function generateAnkiNote(entry) {
         (onyomiEntry) => createEntry(
           `<span class="kanji kanji-onyomi">${onyomiEntry}</span>`
         )
-      ).join("") : '<span class="kanji kanji-onyomi">(no onyomi) (kokuji)</span>',
+      ).join("") : `<span class="kanji kanji-onyomi">(no onyomi) ${entry.kokuji === true ? "(kokuji)" : ""}</span`,
       entry.kunyomi ? entry.kunyomi.map(
         (kunyomiEntry) => createEntry(
           `<span class="kanji kanji-kunyomi">${kunyomiEntry}</span>`
         )
-      ).join("") : '<span class="kanji kanji-kunyomi">(no kunyomi)</span>',
+      ).join("") : `<span class="kanji kanji-kunyomi">(no kunyomi) ${entry.kokuji === true ? "(kokuji)" : ""}</span>`,
       entry.nanori ? entry.nanori.map(
         (nanoriEntry) => createEntry(
           `<span class="kanji kanji-nanori">${nanoriEntry}</span>`