twl-generator 1.0.4 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "twl-generator",
-  "version": "1.0.4",
+  "version": "1.1.2",
   "description": "Generate term-to-article lists from unfoldingWord en_tw archive for Bible books. Works in both Node.js (CLI) and React.js (browser) environments.",
   "main": "src/index.js",
   "bin": {
@@ -46,7 +46,7 @@
     "node": ">=16.0.0"
   },
   "dependencies": {
-    "adm-zip": "^0.5.10",
+    "jszip": "^3.10.1",
     "node-fetch": "^3.3.2"
   },
   "peerDependencies": {

package/src/utils/zipProcessor.js

@@ -1,8 +1,7 @@
 /**
  * Universal TWL zipProcessor - Works in both Node.js and Browser environments
  * 
- * For Node.js (CLI): Uses file system caching with article_terms.json
- * For React.js/Browser: Uses localStorage/sessionStorage for persistent caching
+ * Caches the raw ZIP file and processes term headers on-demand
  * 
  * Usage in React.js:
  *   import { generateTWTerms } from './utils/zipProcessor.js';
@@ -16,40 +15,78 @@ const isNode = typeof process !== 'undefined' && process.versions?.node;
 const isBrowser = typeof window !== 'undefined';
 
 const ZIP_URL = 'https://git.door43.org/unfoldingWord/en_tw/archive/master.zip';
-const CACHE_KEY = 'twl_article_terms';
+const CACHE_KEY = 'twl_zip_cache';
 const CACHE_VERSION = '1.0';
 
-// In-memory cache for current session
-let memoryCache = null;
+// In-memory cache for processed terms (per session)
+let processedTermsCache = null;
 
 /**
- * Get Node.js dependencies dynamically
+ * Get dependencies dynamically (JSZip works in both environments)
  */
-async function getNodeDeps() {
-  if (!isNode) return null;
-
+async function getDeps() {
   try {
-    const [nodeModule, fsModule, pathModule, urlModule, admZipModule] = await Promise.all([
-      import('node-fetch'),
-      import('fs'),
-      import('path'),
-      import('url'),
-      import('adm-zip')
-    ]);
-
-    return {
-      fetch: nodeModule.default,
-      fs: fsModule.default,
-      path: pathModule.default,
-      fileURLToPath: urlModule.fileURLToPath,
-      AdmZip: admZipModule.default
+    const jsZipModule = await import('jszip');
+    const deps = {
+      JSZip: jsZipModule.default
     };
+
+    // Add Node.js-specific fetch if needed
+    if (isNode) {
+      const nodeModule = await import('node-fetch');
+      deps.fetch = nodeModule.default;
+    }
+
+    return deps;
   } catch (error) {
-    console.error('Failed to load Node.js dependencies:', error);
+    console.error('Failed to load dependencies:', error);
     return null;
   }
 }
 
+async function getCachedZip() {
+  if (isBrowser) {
+    // Browser: Use localStorage for ZIP cache
+    try {
+      const cached = localStorage.getItem(CACHE_KEY);
+      if (cached) {
+        const data = JSON.parse(cached);
+        if (data.version === CACHE_VERSION) {
+          console.log('Using cached ZIP from browser storage');
+          return new Uint8Array(data.zipData);
+        } else {
+          localStorage.removeItem(CACHE_KEY);
+        }
+      }
+    } catch (error) {
+      console.log('Browser ZIP cache corrupted, re-downloading...');
+      try { localStorage.removeItem(CACHE_KEY); } catch (e) { }
+    }
+  }
+  // Note: In Node.js we could cache to filesystem, but fresh download is fine for CLI usage
+
+  return null;
+}
+
+/**
+ * Cache ZIP data in appropriate storage  
+ */
+async function cacheZip(zipBuffer) {
+  if (isBrowser) {
+    try {
+      const cacheData = {
+        version: CACHE_VERSION,
+        timestamp: Date.now(),
+        zipData: Array.from(new Uint8Array(zipBuffer))
+      };
+      localStorage.setItem(CACHE_KEY, JSON.stringify(cacheData));
+      console.log('ZIP cached in browser storage');
+    } catch (error) {
+      console.warn('Failed to cache ZIP in browser:', error.message);
+    }
+  }
+}
+
 /**
  * Get browser storage (localStorage or sessionStorage)
  */
@@ -166,134 +203,116 @@ async function cacheTerms(termMap) {
 }
 
 /**
- * Process zip in Node.js environment using AdmZip
+ * Process ZIP buffer and extract term mappings
  */
-function processNodeZip(AdmZip, Buffer, buffer) {
-  const zip = new AdmZip(Buffer.from(buffer));
-  return zip.getEntries().filter(e => e.entryName.match(/^en_tw\/bible\/.*\/.*\.md$/));
-}
+async function processZipBuffer(zipBuffer) {
+  // Use JSZip universally for both Node.js and Browser
+  const deps = await getDeps();
+  if (!deps) throw new Error('Failed to load dependencies');
+  const { JSZip } = deps;
+
+  const zip = new JSZip();
+  const zipData = await zip.loadAsync(zipBuffer);
+
+  const entries = [];
+  zipData.forEach((relativePath, file) => {
+    if (relativePath.match(/^en_tw\/bible\/.*\/.*\.md$/) && !file.dir) {
+      entries.push({
+        entryName: relativePath,
+        getData: () => file.async('string') // Return promise for string content
+      });
+    }
+  });
 
-/**
- * Process zip in browser environment using native APIs
- */
-async function processBrowserZip(buffer) {
-  // For browser compatibility, we'll throw an error for now
-  // This would require a browser-compatible zip library or different approach
-  throw new Error('ZIP processing in browser requires cached terms. Please ensure article_terms.json is available or use Node.js environment for initial processing.');
+  entries.sort((a, b) => a.entryName.localeCompare(b.entryName));
+
+  const termMap = {};
+
+  for (const entry of entries) {
+    const content = await entry.getData(); // Await the async string content
+    const firstLine = content.split('\n')[0];
+    const terms = firstLine.replace(/^#/, '').trim().split(',').map(t => t.trim()).filter(Boolean);
+    const truncated = entry.entryName.replace('en_tw/bible/', '');
+
+    for (const term of terms) {
+      // Normalize terms by removing parentheses and spaces before them
+      // e.g., "Joseph (OT)" -> "Joseph", "Mary (sister of Martha)" -> "Mary"
+      const normalizedTerm = term.replace(/\s+\([^)]*\)$/, '').trim();
+
+      if (!termMap[normalizedTerm]) {
+        termMap[normalizedTerm] = [];
+      }
+      termMap[normalizedTerm].push(truncated);
+    }
+  }
+
+  // Sort article arrays for consistent output
+  for (const term in termMap) {
+    termMap[term].sort();
+  }
+
+  return termMap;
 }
 
 export async function generateTWTerms() {
-  // Try to get cached terms first
-  const cachedTerms = await getCachedTerms();
-  if (cachedTerms) {
-    return cachedTerms;
+  // Check if we already processed terms this session
+  if (processedTermsCache) {
+    console.log('Using in-memory processed terms');
+    return processedTermsCache;
   }
 
-  console.log('Downloading TW archive...');
+  // Try to get cached ZIP first
+  let zipBuffer = await getCachedZip();
 
-  try {
-    // Get appropriate fetch function and zip processing
-    let fetchFn, processZip;
+  if (!zipBuffer) {
+    // Download fresh ZIP
+    console.log('Downloading TW archive...');
 
+    let fetchFn;
     if (isBrowser) {
       fetchFn = window.fetch;
-      // Use browser-compatible zip processing
-      processZip = (buffer) => processBrowserZip(buffer);
-    } else if (isNode) {
-      const deps = await getNodeDeps();
-      if (!deps) throw new Error('Failed to load Node.js dependencies');
-      fetchFn = deps.fetch;
-      const AdmZip = deps.AdmZip;
-      const Buffer = (await import('buffer')).Buffer;
-      processZip = (buffer) => processNodeZip(AdmZip, Buffer, buffer);
+    } else {
+      const deps = await getDeps();
+      fetchFn = deps?.fetch;
     }
 
-    const res = await fetchFn(ZIP_URL);
-    if (!res.ok) throw new Error(`Failed to download zip: ${res.status} ${res.statusText}`);
-
-    const buffer = await res.arrayBuffer();
-    const entries = await processZip(buffer);
-
-    console.log('Processing TW articles...');
-    entries.sort((a, b) => a.entryName.localeCompare(b.entryName));
+    if (!fetchFn) throw new Error('Fetch not available');
 
-    const termMap = {};
-
-    for (const entry of entries) {
-      const content = entry.getData().toString('utf8');
-      const firstLine = content.split('\n')[0];
-      const terms = firstLine.replace(/^#/, '').trim().split(',').map(t => t.trim()).filter(Boolean);
-      const truncated = entry.entryName.replace('en_tw/bible/', '');
+    const res = await fetchFn(ZIP_URL);
+    if (!res.ok) throw new Error(`Failed to download ZIP: ${res.status} ${res.statusText}`);
 
-      for (const term of terms) {
-        // Normalize terms by removing parentheses and spaces before them
-        // e.g., "Joseph (OT)" -> "Joseph", "Mary (sister of Martha)" -> "Mary"
-        const normalizedTerm = term.replace(/\s+\([^)]*\)$/, '').trim();
+    zipBuffer = await res.arrayBuffer();
 
-        if (!termMap[normalizedTerm]) {
-          termMap[normalizedTerm] = [];
-        }
-        termMap[normalizedTerm].push(truncated);
-      }
-    }
-
-    // Sort article arrays for consistent output
-    for (const term in termMap) {
-      termMap[term].sort();
-    }
+    // Cache the ZIP for next time
+    await cacheZip(zipBuffer);
+  }
 
-    console.log(`Generated ${Object.keys(termMap).length} terms from TW archive`);
+  // Process ZIP to extract terms
+  console.log('Processing TW articles...');
+  const termMap = await processZipBuffer(zipBuffer);
 
-    // Cache the results
-    await cacheTerms(termMap);
+  console.log(`Generated ${Object.keys(termMap).length} terms from TW archive`);
 
-    return termMap;
+  // Cache processed terms for this session
+  processedTermsCache = termMap;
 
-  } catch (error) {
-    console.error('Error generating TW terms:', error);
-    throw error;
-  }
+  return termMap;
 }
 
 /**
- * Clear cache - useful for forcing refresh in React.js apps
- * @returns {Promise<boolean>} - true if cache was cleared successfully
+ * Clear cache - useful for forcing refresh
  */
 export async function clearCache() {
   // Clear in-memory cache
-  memoryCache = null;
+  processedTermsCache = null;
 
   if (isBrowser) {
-    // Clear browser storage
-    const storage = getBrowserStorage();
-    if (storage) {
-      try {
-        storage.removeItem(CACHE_KEY);
-        console.log('Browser cache cleared');
-        return true;
-      } catch (error) {
-        console.warn('Failed to clear browser cache:', error.message);
-        return false;
-      }
-    }
-  } else if (isNode) {
-    // Clear Node.js file cache
     try {
-      const deps = await getNodeDeps();
-      if (deps) {
-        const { fs, path, fileURLToPath } = deps;
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = path.dirname(__filename);
-        const CACHE_FILE = path.join(__dirname, '../../article_terms.json');
-
-        if (fs.existsSync(CACHE_FILE)) {
-          fs.unlinkSync(CACHE_FILE);
-          console.log('File cache cleared');
-          return true;
-        }
-      }
+      localStorage.removeItem(CACHE_KEY);
+      console.log('Browser ZIP cache cleared');
+      return true;
     } catch (error) {
-      console.warn('Failed to clear file cache:', error.message);
+      console.warn('Failed to clear browser cache:', error.message);
       return false;
     }
   }
@@ -303,45 +322,33 @@ export async function clearCache() {
 }
 
 /**
- * Get cache information for debugging - useful in React.js development
- * @returns {Object} - cache status and info
+ * Get cache information for debugging
  */
 export function getCacheInfo() {
   const info = {
     environment: isNode ? 'Node.js' : (isBrowser ? 'Browser' : 'Unknown'),
-    hasMemoryCache: !!memoryCache,
-    hasPersistentCache: false,
-    cacheType: null,
-    version: null,
-    timestamp: null,
-    termCount: 0
+    hasProcessedTerms: !!processedTermsCache,
+    hasZipCache: false,
+    termCount: 0,
+    cacheVersion: CACHE_VERSION
   };
 
-  // Memory cache info
-  if (memoryCache) {
-    info.termCount = Object.keys(memoryCache).length;
+  // Check processed terms
+  if (processedTermsCache) {
+    info.termCount = Object.keys(processedTermsCache).length;
   }
 
+  // Check ZIP cache in browser
   if (isBrowser) {
-    // Browser cache info
-    const storage = getBrowserStorage();
-    if (storage) {
-      try {
-        const cached = storage.getItem(CACHE_KEY);
-        if (cached) {
-          const data = JSON.parse(cached);
-          info.hasPersistentCache = true;
-          info.cacheType = storage === localStorage ? 'localStorage' : 'sessionStorage';
-          info.version = data.version;
-          info.timestamp = data.timestamp ? new Date(data.timestamp) : null;
-
-          if (!info.termCount && data.terms) {
-            info.termCount = Object.keys(data.terms).length;
-          }
-        }
-      } catch (error) {
-        // Ignore parse errors
+    try {
+      const cached = localStorage.getItem(CACHE_KEY);
+      if (cached) {
+        const data = JSON.parse(cached);
+        info.hasZipCache = true;
+        info.timestamp = data.timestamp ? new Date(data.timestamp) : null;
       }
+    } catch (error) {
+      // Ignore parse errors
     }
   }