fix(readability): import hyphen dependencies statically

Author: cwjwisse

src/readability/shared/multilingual-readability.js

@@ -18,6 +18,22 @@
 
 import { syllable as syllableEn } from 'syllable';
 
+// Static imports for hyphenation patterns (required for Lambda bundling)
+import hyphenDe from 'hyphen/de/index.js';
+import hyphenEs from 'hyphen/es/index.js';
+import hyphenIt from 'hyphen/it/index.js';
+import hyphenFr from 'hyphen/fr/index.js';
+import hyphenNl from 'hyphen/nl/index.js';
+
+// Map of locale to statically imported hyphenation module
+const HYPHEN_MODULES = Object.freeze({
+  de: hyphenDe,
+  es: hyphenEs,
+  it: hyphenIt,
+  fr: hyphenFr,
+  nl: hyphenNl,
+});
+
 export const SUPPORTED_LANGUAGES = {
   eng: 'english',
   deu: 'german',
@@ -56,41 +72,34 @@ const COEFFS = Object.freeze({
   english: { A: 206.835, wps: 1.015, spw: 84.6 },
 });
 
-// Optional: in-flight promise cache to dedupe concurrent analyze() calls
-const syllablePromiseCache = new Map(); // key -> Promise<number>
-
 const clamp = (x) => Math.max(0, Math.min(100, x));
 
-// --- Hyphenation loader (lazy) ---
-// cache promises to dedupe concurrent calls
-const hyphenatorCache = new Map(); // Map<string, Promise<Function|null>>
+// --- Hyphenation loader (using static imports) ---
+// cache to store resolved hyphenators
+const hyphenatorCache = new Map(); // Map<string, Function|null>
 
-export async function getHyphenator(language) {
+export function getHyphenator(language) {
   const key = String(language).toLowerCase();
   const cached = hyphenatorCache.get(key);
-  if (cached) return cached;
-
-  const loader = (async () => {
-    const locale = LOCALE_MAP[key];
-    if (!locale) {
-      // eslint-disable-next-line no-console
-      console.info(`[readability-suggest multilingual] 🔤 No hyphenation patterns available for language: ${language}`);
-      return null;
-    }
+  if (cached !== undefined) return cached;
 
+  const locale = LOCALE_MAP[key];
+  if (!locale) {
     // eslint-disable-next-line no-console
-    console.info(`[readability-suggest multilingual] 📚 Loading hyphenation patterns for ${language} (locale: ${locale})`);
-    const mod = await import(`hyphen/${locale}/index.js`);
-    const hyphenate = mod?.default?.hyphenate;
-    if (hyphenate) {
-      // eslint-disable-next-line no-console
-      console.info(`[readability-suggest multilingual] ✅ Successfully loaded hyphenation patterns for ${language}`);
-    }
-    return hyphenate;
-  })();
+    console.info(`[readability-suggest multilingual] 🔤 No hyphenation patterns available for language: ${language}`);
+    hyphenatorCache.set(key, null);
+    return null;
+  }
 
-  hyphenatorCache.set(key, loader);
-  return loader;
+  const mod = HYPHEN_MODULES[locale];
+  // Use hyphenateSync for better performance (no async overhead)
+  const hyphenate = mod?.hyphenateSync;
+  if (hyphenate) {
+    // eslint-disable-next-line no-console
+    console.info(`[readability-suggest multilingual] ✅ Loaded hyphenation patterns for ${language}`);
+  }
+  hyphenatorCache.set(key, hyphenate || null);
+  return hyphenate || null;
 }
 
 // --- Tokenization (streaming, locale-aware) ---
@@ -151,12 +160,12 @@ const defaultComplexThreshold = 3;
  * Count syllables for a single word in a given language.
  * EN uses "syllable"; others use hyphenation splits as proxy.
  */
-async function countSyllablesWord(word, language) {
+function countSyllablesWord(word, language) {
   const lang = language.toLowerCase();
   if (lang === 'english') {
     return Math.max(1, syllableEn(word));
   }
-  const hyphenate = await getHyphenator(lang);
+  const hyphenate = getHyphenator(lang);
   if (!hyphenate) {
     // generic Unicode vowel group fallback
     const m = word.toLowerCase().match(/[aeiouyà-ɏ]+/giu);
@@ -172,7 +181,7 @@ async function countSyllablesWord(word, language) {
   }
   // Preserve inner apostrophes/dashes, remove other junk
   const cleaned = word.replace(/[^\p{L}\p{M}''-]/gu, '');
-  const hyphenatedString = await hyphenate(cleaned);
+  const hyphenatedString = hyphenate(cleaned);
   // Split by soft hyphen character (U+00AD) to get syllable parts
   const syllableParts = hyphenatedString ? hyphenatedString.split('\u00AD') : [word];
   const syllableCount = Math.max(1, syllableParts.length);
@@ -251,41 +260,16 @@ export async function analyzeReadability(text, language, opts = {}) {
     else entries.set(key, { word: w, count: 1 });
   }
 
-  // 2) Resolve syllables per unique word, using cache and deduped promises
-  const toResolve = [];
+  // 2) Resolve syllables per unique word, using cache
   for (const [key, { word }] of entries) {
     if (cache.get(key) == null) {
-      let p = syllablePromiseCache.get(key);
-      if (!p) {
-        p = countSyllablesWord(word, lang).then((n) => {
-          cache.set(key, n);
-          syllablePromiseCache.delete(key); // keep cache small
-          return n;
-        });
-        syllablePromiseCache.set(key, p);
-      }
-      toResolve.push(p);
+      cache.set(key, countSyllablesWord(word, lang));
     }
   }
-  if (toResolve.length) await Promise.all(toResolve);
 
   // 3) Aggregate syllables/complex words using frequencies
   let syllableCount = 0;
   let complexWords = 0;
-  // CRITICAL FIX: Check for corrupted cache entries and recalculate if needed
-  const toRecalculate = [];
-  for (const [key, { word }] of entries) {
-    const s = cache.get(key);
-    // If cache returns undefined/null or 0 syllables, need to recalculate
-    if (s === undefined || s === null || s === 0) {
-      toRecalculate.push(countSyllablesWord(word, lang).then((n) => {
-        cache.set(key, n);
-        return n;
-      }));
-    }
-  }
-  if (toRecalculate.length) await Promise.all(toRecalculate);
-
   for (const [key, { count }] of entries) {
     const s = cache.get(key) ?? 0;
     syllableCount += s * count;