@nlabs/reaktor 0.10.2 → 0.10.6

package/lib/utils/translationQueue.example.js

@@ -1,2 +1,340 @@
-import{flush as l,i18n as r}from"./translationQueue.js";async function f(o,t="en"){return await r(o,[{key:"welcome.title",fallback:"Welcome to TorchOne!"},{key:"welcome.subtitle",fallback:"Your personal AI assistant"},{key:"welcome.description",fallback:"Get started by exploring our features"}],t)}async function u(o,t,e="en"){const n=[{key:"user.welcome",fallback:"Welcome back, {{username}}!",params:{username:t}},{key:"user.notifications",fallback:"You have {{count}} new notifications",params:{count:5}},{key:"user.lastLogin",fallback:"Last login: {{date}}",params:{date:new Date().toLocaleDateString()}}];return await r(o,n,e)}async function m(o){const t=["en","es","fr"],e={};for(const n of t){const a=[{key:"app.name",fallback:"TorchOne"},{key:"app.tagline",fallback:"Your AI Assistant"}];e[n]=await r(o,a,n)}return e}async function p(o,t="en"){const e=[{key:"error.notFound",fallback:"Content not found"},{key:"error.serverError",fallback:"Server error occurred"},{key:"success.saved",fallback:"Content saved successfully"}];try{return await r(o,e,t)}catch{return e.reduce((a,s)=>(a[s.key]=s.fallback||"",a),{})}}async function b(o,t="en"){const e=[];for(let a=1;a<=100;a++)e.push({key:`item.${a}.title`,fallback:`Item ${a} Title`,params:{number:a}});const n=await r(o,e,t);return await l(),n}async function g(o,t,e="en"){const n=[{key:`error.${t}`,fallback:`An error occurred: ${t}`,params:{errorCode:t}},{key:"error.contactSupport",fallback:"Please contact support if this problem persists.",params:{}}];return await r(o,n,e)}async function k(o,t,e="en"){const n=[{key:"email.orderConfirmation.subject",fallback:"Order {{orderId}} Confirmed",params:{orderId:t.orderId}},{key:"email.orderConfirmation.greeting",fallback:"Hello {{name}},",params:{name:t.name}},{key:"email.orderConfirmation.body",fallback:"Your order {{orderId}} has been confirmed. Total: ${{total}} for {{items}} items.",params:{orderId:t.orderId,total:t.total,items:t.items}},{key:"email.orderConfirmation.footer",fallback:"Thank you for your purchase!"}],a=await r(o,n,e);return{subject:a["email.orderConfirmation.subject"],greeting:a["email.orderConfirmation.greeting"],body:a["email.orderConfirmation.body"],footer:a["email.orderConfirmation.footer"]}}async function d(o,t="en"){return await r(o,[{key:"notification.welcome",fallback:"Welcome to TorchOne!"},{key:"notification.verification",fallback:"Please verify your account."},{key:"notification.passwordReset",fallback:"Your password has been reset."},{key:"notification.profileUpdate",fallback:"Your profile has been updated."},{key:"notification.newMessage",fallback:"You have a new message from {{sender}}.",params:{sender:"John Doe"}}],t)}async function y(o){const e=["welcome","verification","passwordReset","profileUpdate","email.subject","email.body","sms.welcome","sms.verification"].map(a=>({key:a,fallback:`Fallback for ${a}`}));return await r(o,e,"en")}async function w(o,t,e){const s=await r(o,[{key:"greeting.morning",fallback:"Good morning!",params:e?{username:e}:{}},{key:"greeting.afternoon",fallback:"Good afternoon!",params:e?{username:e}:{}},{key:"greeting.evening",fallback:"Good evening!",params:e?{username:e}:{}}],t||"en"),i=new Date().getHours();return i<12?s["greeting.morning"]:i<18?s["greeting.afternoon"]:s["greeting.evening"]}async function h(){await l()}export{h as ensureAllTranslationsProcessed,k as generateEmailTemplate,g as getErrorMessages,m as getMultiLanguageContent,d as getNotificationMessages,u as getPersonalizedMessages,p as getRobustTranslations,w as getUserGreeting,f as getWelcomeMessages,y as performanceComparison,b as processLargeTranslationBatch};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/utils/translationQueue.example.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n *\n * Example usage of the translation queue system with Google Translate integration\n *\n * This demonstrates how to use the new translation queue that automatically\n * translates content using Google Translate API when needed.\n */\n\nimport {flush, i18n, type TranslationObject} from './translationQueue.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {Locale} from '../types/content.types.js';\n\n// Example 1: Basic translations - will use database or translate as needed\nexport async function getWelcomeMessages(context: ApiContext, locale: Locale = 'en') {\n  const translations: TranslationObject[] = [\n    {\n      key: 'welcome.title',\n      fallback: 'Welcome to TorchOne!'\n    },\n    {\n      key: 'welcome.subtitle',\n      fallback: 'Your personal AI assistant'\n    },\n    {\n      key: 'welcome.description',\n      fallback: 'Get started by exploring our features'\n    }\n  ];\n\n  // This will:\n  // 1. Check database for existing translations\n  // 2. If not found and locale is default (en), save fallback to DB\n  // 3. If not found and locale is different, translate from default locale\n  // 4. Save translated content to DB for future use\n  const result = await i18n (context, translations, locale);\n\n  return result;\n  // Returns: {\n  //   'welcome.title': 'Welcome to TorchOne!' (or translated version),\n  //   'welcome.subtitle': 'Your personal AI assistant' (or translated version),\n  //   'welcome.description': 'Get started by exploring our features' (or translated version)\n  // }\n}\n\n// Example 2: Translations with interpolation\nexport async function getPersonalizedMessages(context: ApiContext, username: string, locale: Locale = 'en') {\n  const translations: TranslationObject[] = [\n    {\n      key: 'user.welcome',\n      fallback: 'Welcome back, {{username}}!',\n      params: {username}\n    },\n    {\n      key: 'user.notifications',\n      fallback: 'You have {{count}} new notifications',\n      params: {count: 5}\n    },\n    {\n      key: 'user.lastLogin',\n      fallback: 'Last login: {{date}}',\n      params: {date: new Date().toLocaleDateString()}\n    }\n  ];\n\n  const result = await i18n(context, translations, locale);\n\n  return result;\n  // Returns: {\n  //   'user.welcome': 'Welcome back, Alice!' (or translated with interpolation),\n  //   'user.notifications': 'You have 5 new notifications' (or translated with interpolation),\n  //   'user.lastLogin': 'Last login: 1/15/2025' (or translated with interpolation)\n  // }\n}\n\n// Example 3: Multi-language support\nexport async function getMultiLanguageContent(context: ApiContext) {\n  // Get content in multiple languages\n  const languages: Locale[] = ['en', 'es', 'fr'];\n  const results: Record<Locale, Record<string, string>> = {} as any;\n\n  for(const locale of languages) {\n    const translations: TranslationObject[] = [\n      {\n        key: 'app.name',\n        fallback: 'TorchOne'\n      },\n      {\n        key: 'app.tagline',\n        fallback: 'Your AI Assistant'\n      }\n    ];\n\n    results[locale] = await i18n(context, translations, locale);\n  }\n\n  return results;\n  // Returns: {\n  //   en: { 'app.name': 'TorchOne', 'app.tagline': 'Your AI Assistant' },\n  //   es: { 'app.name': 'TorchOne', 'app.tagline': 'Tu Asistente de IA' },\n  //   fr: { 'app.name': 'TorchOne', 'app.tagline': 'Votre Assistant IA' }\n  // }\n}\n\n// Example 4: Error handling and fallbacks\nexport async function getRobustTranslations(context: ApiContext, locale: Locale = 'en') {\n  const translations: TranslationObject[] = [\n    {\n      key: 'error.notFound',\n      fallback: 'Content not found'\n    },\n    {\n      key: 'error.serverError',\n      fallback: 'Server error occurred'\n    },\n    {\n      key: 'success.saved',\n      fallback: 'Content saved successfully'\n    }\n  ];\n\n  try {\n    const result = await i18n(context, translations, locale);\n    return result;\n  } catch(error) {\n    console.error('Translation error:', error);\n    // Return fallbacks if translation fails\n    return translations.reduce((acc, t) => {\n      acc[t.key] = t.fallback || '';\n      return acc;\n    }, {} as Record<string, string>);\n  }\n}\n\n// Example 5: Batch processing with flush\nexport async function processLargeTranslationBatch(context: ApiContext, locale: Locale = 'en') {\n  // Create a large batch of translations\n  const translations: TranslationObject[] = [];\n\n  for(let i = 1; i <= 100; i++) {\n    translations.push({\n      key: `item.${i}.title`,\n      fallback: `Item ${i} Title`,\n      params: {number: i}\n    });\n  }\n\n  // Process the batch\n  const result = await i18n(context, translations, locale);\n\n  // Ensure all pending translations are processed\n  await flush();\n\n  return result;\n}\n\n// Example 6: Error handling with fallbacks\nexport async function getErrorMessages(context: ApiContext, errorCode: string, locale: Locale = 'en') {\n  const translations: TranslationObject[] = [\n    {\n      key: `error.${errorCode}`,\n      fallback: `An error occurred: ${errorCode}`,\n      params: {errorCode}\n    },\n    {\n      key: 'error.contactSupport',\n      fallback: 'Please contact support if this problem persists.',\n      params: {}\n    }\n  ];\n\n  const result = await i18n(context, translations, locale);\n\n  // If database is unavailable, will return fallbacks:\n  // {\n  //   'error.INVALID_EMAIL': 'An error occurred: INVALID_EMAIL',\n  //   'error.contactSupport': 'Please contact support if this problem persists.'\n  // }\n\n  return result;\n}\n\n// Example 7: Complex email template with multiple interpolations\nexport async function generateEmailTemplate(\n  context: ApiContext,\n  userData: {\n    name: string;\n    email: string;\n    orderId: string;\n    total: number;\n    items: number;\n  },\n  locale: Locale = 'en'\n) {\n  const translations: TranslationObject[] = [\n    {\n      key: 'email.orderConfirmation.subject',\n      fallback: 'Order {{orderId}} Confirmed',\n      params: {orderId: userData.orderId}\n    },\n    {\n      key: 'email.orderConfirmation.greeting',\n      fallback: 'Hello {{name}},',\n      params: {name: userData.name}\n    },\n    {\n      key: 'email.orderConfirmation.body',\n      fallback: 'Your order {{orderId}} has been confirmed. Total: ${{total}} for {{items}} items.',\n      params: {\n        orderId: userData.orderId,\n        total: userData.total,\n        items: userData.items\n      }\n    },\n    {\n      key: 'email.orderConfirmation.footer',\n      fallback: 'Thank you for your purchase!'\n    }\n  ];\n\n  const result = await i18n(context, translations, locale);\n\n  return {\n    subject: result['email.orderConfirmation.subject'],\n    greeting: result['email.orderConfirmation.greeting'],\n    body: result['email.orderConfirmation.body'],\n    footer: result['email.orderConfirmation.footer']\n  };\n}\n\n// Example 8: Notification messages for different scenarios\nexport async function getNotificationMessages(context: ApiContext, locale: Locale = 'en') {\n  const translations: TranslationObject[] = [\n    {\n      key: 'notification.welcome',\n      fallback: 'Welcome to TorchOne!'\n    },\n    {\n      key: 'notification.verification',\n      fallback: 'Please verify your account.'\n    },\n    {\n      key: 'notification.passwordReset',\n      fallback: 'Your password has been reset.'\n    },\n    {\n      key: 'notification.profileUpdate',\n      fallback: 'Your profile has been updated.'\n    },\n    {\n      key: 'notification.newMessage',\n      fallback: 'You have a new message from {{sender}}.',\n      params: {sender: 'John Doe'}\n    }\n  ];\n\n  const result = await i18n(context, translations, locale);\n\n  return result;\n}\n\n// Example 9: Performance comparison\nexport async function performanceComparison(context: ApiContext) {\n  const keys = [\n    'welcome', 'verification', 'passwordReset', 'profileUpdate',\n    'email.subject', 'email.body', 'sms.welcome', 'sms.verification'\n  ];\n\n  const translations: TranslationObject[] = keys.map((key) => ({\n    key,\n    fallback: `Fallback for ${key}`\n  }));\n\n  console.time('Batch translation');\n  const batchResults = await i18n(context, translations, 'en');\n  console.timeEnd('Batch translation');\n\n  return batchResults;\n}\n\n// Example 10: Dynamic content based on user preferences\nexport async function getUserGreeting(\n  context: ApiContext,\n  userLocale?: string,\n  username?: string\n) {\n  const locale: Locale = (userLocale as Locale) || 'en';\n\n  const translations: TranslationObject[] = [\n    {\n      key: 'greeting.morning',\n      fallback: 'Good morning!',\n      params: username ? {username} : {}\n    },\n    {\n      key: 'greeting.afternoon',\n      fallback: 'Good afternoon!',\n      params: username ? {username} : {}\n    },\n    {\n      key: 'greeting.evening',\n      fallback: 'Good evening!',\n      params: username ? {username} : {}\n    }\n  ];\n\n  const result = await i18n(context, translations, locale);\n\n  // Return appropriate greeting based on time of day\n  const hour = new Date().getHours();\n  if(hour < 12) {\n    return result['greeting.morning'];\n  }\n  if(hour < 18) {\n    return result['greeting.afternoon'];\n  }\n  return result['greeting.evening'];\n}\n\n// Example 11: Force flush pending translations\nexport async function ensureAllTranslationsProcessed() {\n  // Force process any pending translation batches\n  await flush();\n  console.log('All translation batches processed');\n}\n\n// Usage examples:\n// const context = { databaseName: 'torchone-dev', session: { userId: 'user123' } };\n//\n// // Basic usage\n// const welcomeMessages = await getWelcomeMessages(context, 'en');\n//\n// // With interpolation\n// const personalizedMessages = await getPersonalizedMessages(context, 'John', 'es');\n//\n// // Multi-language content\n// const multiLanguageContent = await getMultiLanguageContent(context);\n//\n// // Error handling\n// const errorMessages = await getRobustTranslations(context, 'de');\n//\n// // Complex template\n// const emailTemplate = await generateEmailTemplate(context, {\n//   name: 'Maria',\n//   email: 'maria@example.com',\n//   orderId: 'ORD-123',\n//   total: 99.99,\n//   items: 3\n// }, 'pt');\n//\n// // Notifications\n// const notifications = await getNotificationMessages(context, 'fr');\n//\n// // Performance test\n// const perf = await performanceComparison(context);\n//\n// // Dynamic greeting\n// const greeting = await getUserGreeting(context, 'en', 'John');\n//\n// // Force flush\n// await ensureAllTranslationsProcessed();"],
  "mappings": "AAUA,OAAQ,SAAAA,EAAO,QAAAC,MAAmC,wBAMlD,eAAsBC,EAAmBC,EAAqBC,EAAiB,KAAM,CAuBnF,OAFe,MAAMH,EAAME,EApBe,CACxC,CACE,IAAK,gBACL,SAAU,sBACZ,EACA,CACE,IAAK,mBACL,SAAU,4BACZ,EACA,CACE,IAAK,sBACL,SAAU,uCACZ,CACF,EAOkDC,CAAM,CAQ1D,CAGA,eAAsBC,EAAwBF,EAAqBG,EAAkBF,EAAiB,KAAM,CAC1G,MAAMG,EAAoC,CACxC,CACE,IAAK,eACL,SAAU,8BACV,OAAQ,CAAC,SAAAD,CAAQ,CACnB,EACA,CACE,IAAK,qBACL,SAAU,uCACV,OAAQ,CAAC,MAAO,CAAC,CACnB,EACA,CACE,IAAK,iBACL,SAAU,uBACV,OAAQ,CAAC,KAAM,IAAI,KAAK,EAAE,mBAAmB,CAAC,CAChD,CACF,EAIA,OAFe,MAAML,EAAKE,EAASI,EAAcH,CAAM,CAQzD,CAGA,eAAsBI,EAAwBL,EAAqB,CAEjE,MAAMM,EAAsB,CAAC,KAAM,KAAM,IAAI,EACvCC,EAAkD,CAAC,EAEzD,UAAUN,KAAUK,EAAW,CAC7B,MAAMF,EAAoC,CACxC,CACE,IAAK,WACL,SAAU,UACZ,EACA,CACE,IAAK,cACL,SAAU,mBACZ,CACF,EAEAG,EAAQN,CAAM,EAAI,MAAMH,EAAKE,EAASI,EAAcH,CAAM,CAC5D,CAEA,OAAOM,CAMT,CAGA,eAAsBC,EAAsBR,EAAqBC,EAAiB,KAAM,CACtF,MAAMG,EAAoC,CACxC,CACE,IAAK,iBACL,SAAU,mBACZ,EACA,CACE,IAAK,oBACL,SAAU,uBACZ,EACA,CACE,IAAK,gBACL,SAAU,4BACZ,CACF,EAEA,GAAI,CAEF,OADe,MAAMN,EAAKE,EAASI,EAAcH,CAAM,CAEzD,MAAe,CAGb,OAAOG,EAAa,OAAO,CAACK,EAAKC,KAC/BD,EAAIC,EAAE,GAAG,EAAIA,EAAE,UAAY,GACpBD,GACN,CAAC,CAA2B,CACjC,CACF,CAGA,eAAsBE,EAA6BX,EAAqBC,EAAiB,KAAM,CAE7F,MAAMG,EAAoC,CAAC,EAE3C,QAAQQ,EAAI,EAAGA,GAAK,IAAKA,IACvBR,EAAa,KAAK,CAChB,IAAK,QAAQQ,CAAC,SACd,SAAU,QAAQA,CAAC,SACnB,OAAQ,CAAC,OAAQA,CAAC,CACpB,CAAC,EAIH,MAAMC,EAAS,MAAMf,EAAKE,EAASI,EAAcH,CAAM,EAGvD,aAAMJ,EAAM,EAELgB,CACT,CAGA,eAAsBC,EAAiBd,EAAqBe,EAAmBd,EAAiB,KAAM,CACpG,MAAMG,EAAoC,CACxC,CACE,IAAK,SAASW,CAAS,GACvB,SAAU,sBAAsBA,CAAS,GACzC,OAAQ,CAAC,UAAAA,CAAS,CACpB,EACA,CACE,IAAK,uBACL,SAAU,mDACV,OAAQ,CAAC,CACX,CACF,EAUA,OARe,MAAMjB,EAAKE,EAASI,EAAcH,CAAM,CASzD,CAGA,eAAsBe,EACpBhB,EACAiB,EAOAhB,EAAiB,KACjB,CACA,MAAMG,EAAoC,CACxC,CACE,IAAK,kCACL,SAAU,8BACV,OAAQ,CAAC,QAASa,EAAS,OAAO,CACpC,EACA,CACE,IAAK,mCACL,SAAU,kBACV,OAAQ,CAAC,KAAMA,EAAS,IAAI,CAC9B,EACA,CACE,IAAK,+BACL,SAAU,oFACV,OAAQ,CACN,QAASA,EAAS,QAClB,MAAOA,EAAS,MAChB,MAAOA,EAAS,KAClB,CACF,EACA,CACE,IAAK,iCACL,SAAU,8BACZ,CACF,EAEMJ,EAAS,MAAMf,EAAKE,EAASI,EAAcH,CAAM,EAEvD,MAAO,CACL,QAASY,EAAO,iCAAiC,EACjD,SAAUA,EAAO,kCAAkC,EACnD,KAAMA,EAAO,8BAA8B,EAC3C,OAAQA,EAAO,gCAAgC,CACjD,CACF,CAGA,eAAsBK,EAAwBlB,EAAqBC,EAAiB,KAAM,CA2BxF,OAFe,MAAMH,EAAKE,EAxBgB,CACxC,CACE,IAAK,uBACL,SAAU,sBACZ,EACA,CACE,IAAK,4BACL,SAAU,6BACZ,EACA,CACE,IAAK,6BACL,SAAU,+BACZ,EACA,CACE,IAAK,6BACL,SAAU,gCACZ,EACA,CACE,IAAK,0BACL,SAAU,0CACV,OAAQ,CAAC,OAAQ,UAAU,CAC7B,CACF,EAEiDC,CAAM,CAGzD,CAGA,eAAsBkB,EAAsBnB,EAAqB,CAM/D,MAAMI,EALO,CACX,UAAW,eAAgB,gBAAiB,gBAC5C,gBAAiB,aAAc,cAAe,kBAChD,EAE+C,IAAKgB,IAAS,CAC3D,IAAAA,EACA,SAAU,gBAAgBA,CAAG,EAC/B,EAAE,EAMF,OAHqB,MAAMtB,EAAKE,EAASI,EAAc,IAAI,CAI7D,CAGA,eAAsBiB,EACpBrB,EACAsB,EACAnB,EACA,CAqBA,MAAMU,EAAS,MAAMf,EAAKE,EAlBgB,CACxC,CACE,IAAK,mBACL,SAAU,gBACV,OAAQG,EAAW,CAAC,SAAAA,CAAQ,EAAI,CAAC,CACnC,EACA,CACE,IAAK,qBACL,SAAU,kBACV,OAAQA,EAAW,CAAC,SAAAA,CAAQ,EAAI,CAAC,CACnC,EACA,CACE,IAAK,mBACL,SAAU,gBACV,OAAQA,EAAW,CAAC,SAAAA,CAAQ,EAAI,CAAC,CACnC,CACF,EAlBwBmB,GAAyB,IAoBM,EAGjDC,EAAO,IAAI,KAAK,EAAE,SAAS,EACjC,OAAGA,EAAO,GACDV,EAAO,kBAAkB,EAE/BU,EAAO,GACDV,EAAO,oBAAoB,EAE7BA,EAAO,kBAAkB,CAClC,CAGA,eAAsBW,GAAiC,CAErD,MAAM3B,EAAM,CAEd",
  "names": ["flush", "i18n", "getWelcomeMessages", "context", "locale", "getPersonalizedMessages", "username", "translations", "getMultiLanguageContent", "languages", "results", "getRobustTranslations", "acc", "t", "processLargeTranslationBatch", "i", "result", "getErrorMessages", "errorCode", "generateEmailTemplate", "userData", "getNotificationMessages", "performanceComparison", "key", "getUserGreeting", "userLocale", "hour", "ensureAllTranslationsProcessed"]
}

+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ *
+ * Example usage of the translation queue system with Google Translate integration
+ *
+ * This demonstrates how to use the new translation queue that automatically
+ * translates content using Google Translate API when needed.
+ */ import { flush, i18n } from './translationQueue.js';
+// Example 1: Basic translations - will use database or translate as needed
+export async function getWelcomeMessages(context, locale = 'en') {
+    const translations = [
+        {
+            key: 'welcome.title',
+            fallback: 'Welcome to TorchOne!'
+        },
+        {
+            key: 'welcome.subtitle',
+            fallback: 'Your personal AI assistant'
+        },
+        {
+            key: 'welcome.description',
+            fallback: 'Get started by exploring our features'
+        }
+    ];
+    // This will:
+    // 1. Check database for existing translations
+    // 2. If not found and locale is default (en), save fallback to DB
+    // 3. If not found and locale is different, translate from default locale
+    // 4. Save translated content to DB for future use
+    const result = await i18n(context, translations, locale);
+    return result;
+// Returns: {
+//   'welcome.title': 'Welcome to TorchOne!' (or translated version),
+//   'welcome.subtitle': 'Your personal AI assistant' (or translated version),
+//   'welcome.description': 'Get started by exploring our features' (or translated version)
+// }
+}
+// Example 2: Translations with interpolation
+export async function getPersonalizedMessages(context, username, locale = 'en') {
+    const translations = [
+        {
+            key: 'user.welcome',
+            fallback: 'Welcome back, {{username}}!',
+            params: {
+                username
+            }
+        },
+        {
+            key: 'user.notifications',
+            fallback: 'You have {{count}} new notifications',
+            params: {
+                count: 5
+            }
+        },
+        {
+            key: 'user.lastLogin',
+            fallback: 'Last login: {{date}}',
+            params: {
+                date: new Date().toLocaleDateString()
+            }
+        }
+    ];
+    const result = await i18n(context, translations, locale);
+    return result;
+// Returns: {
+//   'user.welcome': 'Welcome back, Alice!' (or translated with interpolation),
+//   'user.notifications': 'You have 5 new notifications' (or translated with interpolation),
+//   'user.lastLogin': 'Last login: 1/15/2025' (or translated with interpolation)
+// }
+}
+// Example 3: Multi-language support
+export async function getMultiLanguageContent(context) {
+    // Get content in multiple languages
+    const languages = [
+        'en',
+        'es',
+        'fr'
+    ];
+    const results = {};
+    for (const locale of languages){
+        const translations = [
+            {
+                key: 'app.name',
+                fallback: 'TorchOne'
+            },
+            {
+                key: 'app.tagline',
+                fallback: 'Your AI Assistant'
+            }
+        ];
+        results[locale] = await i18n(context, translations, locale);
+    }
+    return results;
+// Returns: {
+//   en: { 'app.name': 'TorchOne', 'app.tagline': 'Your AI Assistant' },
+//   es: { 'app.name': 'TorchOne', 'app.tagline': 'Tu Asistente de IA' },
+//   fr: { 'app.name': 'TorchOne', 'app.tagline': 'Votre Assistant IA' }
+// }
+}
+// Example 4: Error handling and fallbacks
+export async function getRobustTranslations(context, locale = 'en') {
+    const translations = [
+        {
+            key: 'error.notFound',
+            fallback: 'Content not found'
+        },
+        {
+            key: 'error.serverError',
+            fallback: 'Server error occurred'
+        },
+        {
+            key: 'success.saved',
+            fallback: 'Content saved successfully'
+        }
+    ];
+    try {
+        const result = await i18n(context, translations, locale);
+        return result;
+    } catch (error) {
+        console.error('Translation error:', error);
+        // Return fallbacks if translation fails
+        return translations.reduce((acc, t)=>{
+            acc[t.key] = t.fallback || '';
+            return acc;
+        }, {});
+    }
+}
+// Example 5: Batch processing with flush
+export async function processLargeTranslationBatch(context, locale = 'en') {
+    // Create a large batch of translations
+    const translations = [];
+    for(let i = 1; i <= 100; i++){
+        translations.push({
+            key: `item.${i}.title`,
+            fallback: `Item ${i} Title`,
+            params: {
+                number: i
+            }
+        });
+    }
+    // Process the batch
+    const result = await i18n(context, translations, locale);
+    // Ensure all pending translations are processed
+    await flush();
+    return result;
+}
+// Example 6: Error handling with fallbacks
+export async function getErrorMessages(context, errorCode, locale = 'en') {
+    const translations = [
+        {
+            key: `error.${errorCode}`,
+            fallback: `An error occurred: ${errorCode}`,
+            params: {
+                errorCode
+            }
+        },
+        {
+            key: 'error.contactSupport',
+            fallback: 'Please contact support if this problem persists.',
+            params: {}
+        }
+    ];
+    const result = await i18n(context, translations, locale);
+    // If database is unavailable, will return fallbacks:
+    // {
+    //   'error.INVALID_EMAIL': 'An error occurred: INVALID_EMAIL',
+    //   'error.contactSupport': 'Please contact support if this problem persists.'
+    // }
+    return result;
+}
+// Example 7: Complex email template with multiple interpolations
+export async function generateEmailTemplate(context, userData, locale = 'en') {
+    const translations = [
+        {
+            key: 'email.orderConfirmation.subject',
+            fallback: 'Order {{orderId}} Confirmed',
+            params: {
+                orderId: userData.orderId
+            }
+        },
+        {
+            key: 'email.orderConfirmation.greeting',
+            fallback: 'Hello {{name}},',
+            params: {
+                name: userData.name
+            }
+        },
+        {
+            key: 'email.orderConfirmation.body',
+            fallback: 'Your order {{orderId}} has been confirmed. Total: ${{total}} for {{items}} items.',
+            params: {
+                orderId: userData.orderId,
+                total: userData.total,
+                items: userData.items
+            }
+        },
+        {
+            key: 'email.orderConfirmation.footer',
+            fallback: 'Thank you for your purchase!'
+        }
+    ];
+    const result = await i18n(context, translations, locale);
+    return {
+        subject: result['email.orderConfirmation.subject'],
+        greeting: result['email.orderConfirmation.greeting'],
+        body: result['email.orderConfirmation.body'],
+        footer: result['email.orderConfirmation.footer']
+    };
+}
+// Example 8: Notification messages for different scenarios
+export async function getNotificationMessages(context, locale = 'en') {
+    const translations = [
+        {
+            key: 'notification.welcome',
+            fallback: 'Welcome to TorchOne!'
+        },
+        {
+            key: 'notification.verification',
+            fallback: 'Please verify your account.'
+        },
+        {
+            key: 'notification.passwordReset',
+            fallback: 'Your password has been reset.'
+        },
+        {
+            key: 'notification.profileUpdate',
+            fallback: 'Your profile has been updated.'
+        },
+        {
+            key: 'notification.newMessage',
+            fallback: 'You have a new message from {{sender}}.',
+            params: {
+                sender: 'John Doe'
+            }
+        }
+    ];
+    const result = await i18n(context, translations, locale);
+    return result;
+}
+// Example 9: Performance comparison
+export async function performanceComparison(context) {
+    const keys = [
+        'welcome',
+        'verification',
+        'passwordReset',
+        'profileUpdate',
+        'email.subject',
+        'email.body',
+        'sms.welcome',
+        'sms.verification'
+    ];
+    const translations = keys.map((key)=>({
+            key,
+            fallback: `Fallback for ${key}`
+        }));
+    console.time('Batch translation');
+    const batchResults = await i18n(context, translations, 'en');
+    console.timeEnd('Batch translation');
+    return batchResults;
+}
+// Example 10: Dynamic content based on user preferences
+export async function getUserGreeting(context, userLocale, username) {
+    const locale = userLocale || 'en';
+    const translations = [
+        {
+            key: 'greeting.morning',
+            fallback: 'Good morning!',
+            params: username ? {
+                username
+            } : {}
+        },
+        {
+            key: 'greeting.afternoon',
+            fallback: 'Good afternoon!',
+            params: username ? {
+                username
+            } : {}
+        },
+        {
+            key: 'greeting.evening',
+            fallback: 'Good evening!',
+            params: username ? {
+                username
+            } : {}
+        }
+    ];
+    const result = await i18n(context, translations, locale);
+    // Return appropriate greeting based on time of day
+    const hour = new Date().getHours();
+    if (hour < 12) {
+        return result['greeting.morning'];
+    }
+    if (hour < 18) {
+        return result['greeting.afternoon'];
+    }
+    return result['greeting.evening'];
+}
+// Example 11: Force flush pending translations
+export async function ensureAllTranslationsProcessed() {
+    // Force process any pending translation batches
+    await flush();
+    console.log('All translation batches processed');
+} // Usage examples:
+ // const context = { databaseName: 'torchone-dev', session: { userId: 'user123' } };
+ //
+ // // Basic usage
+ // const welcomeMessages = await getWelcomeMessages(context, 'en');
+ //
+ // // With interpolation
+ // const personalizedMessages = await getPersonalizedMessages(context, 'John', 'es');
+ //
+ // // Multi-language content
+ // const multiLanguageContent = await getMultiLanguageContent(context);
+ //
+ // // Error handling
+ // const errorMessages = await getRobustTranslations(context, 'de');
+ //
+ // // Complex template
+ // const emailTemplate = await generateEmailTemplate(context, {
+ //   name: 'Maria',
+ //   email: 'maria@example.com',
+ //   orderId: 'ORD-123',
+ //   total: 99.99,
+ //   items: 3
+ // }, 'pt');
+ //
+ // // Notifications
+ // const notifications = await getNotificationMessages(context, 'fr');
+ //
+ // // Performance test
+ // const perf = await performanceComparison(context);
+ //
+ // // Dynamic greeting
+ // const greeting = await getUserGreeting(context, 'en', 'John');
+ //
+ // // Force flush
+ // await ensureAllTranslationsProcessed();
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/utils/translationQueue.example.ts"],"sourcesContent":["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n *\n * Example usage of the translation queue system with Google Translate integration\n *\n * This demonstrates how to use the new translation queue that automatically\n * translates content using Google Translate API when needed.\n */\n\nimport {flush, i18n, type TranslationObject} from './translationQueue.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {Locale} from '../types/content.types.js';\n\n// Example 1: Basic translations - will use database or translate as needed\nexport async function getWelcomeMessages(context: ApiContext, locale: Locale = 'en') {\n  const translations: TranslationObject[] = [\n    {\n      key: 'welcome.title',\n      fallback: 'Welcome to TorchOne!'\n    },\n    {\n      key: 'welcome.subtitle',\n      fallback: 'Your personal AI assistant'\n    },\n    {\n      key: 'welcome.description',\n      fallback: 'Get started by exploring our features'\n    }\n  ];\n\n  // This will:\n  // 1. Check database for existing translations\n  // 2. If not found and locale is default (en), save fallback to DB\n  // 3. If not found and locale is different, translate from default locale\n  // 4. Save translated content to DB for future use\n  const result = await i18n (context, translations, locale);\n\n  return result;\n  // Returns: {\n  //   'welcome.title': 'Welcome to TorchOne!' (or translated version),\n  //   'welcome.subtitle': 'Your personal AI assistant' (or translated version),\n  //   'welcome.description': 'Get started by exploring our features' (or translated version)\n  // }\n}\n\n// Example 2: Translations with interpolation\nexport async function getPersonalizedMessages(context: ApiContext, username: string, locale: Locale = 'en') {\n  const translations: TranslationObject[] = [\n    {\n      key: 'user.welcome',\n      fallback: 'Welcome back, {{username}}!',\n      params: {username}\n    },\n    {\n      key: 'user.notifications',\n      fallback: 'You have {{count}} new notifications',\n      params: {count: 5}\n    },\n    {\n      key: 'user.lastLogin',\n      fallback: 'Last login: {{date}}',\n      params: {date: new Date().toLocaleDateString()}\n    }\n  ];\n\n  const result = await i18n(context, translations, locale);\n\n  return result;\n  // Returns: {\n  //   'user.welcome': 'Welcome back, Alice!' (or translated with interpolation),\n  //   'user.notifications': 'You have 5 new notifications' (or translated with interpolation),\n  //   'user.lastLogin': 'Last login: 1/15/2025' (or translated with interpolation)\n  // }\n}\n\n// Example 3: Multi-language support\nexport async function getMultiLanguageContent(context: ApiContext) {\n  // Get content in multiple languages\n  const languages: Locale[] = ['en', 'es', 'fr'];\n  const results: Record<Locale, Record<string, string>> = {} as any;\n\n  for(const locale of languages) {\n    const translations: TranslationObject[] = [\n      {\n        key: 'app.name',\n        fallback: 'TorchOne'\n      },\n      {\n        key: 'app.tagline',\n        fallback: 'Your AI Assistant'\n      }\n    ];\n\n    results[locale] = await i18n(context, translations, locale);\n  }\n\n  return results;\n  // Returns: {\n  //   en: { 'app.name': 'TorchOne', 'app.tagline': 'Your AI Assistant' },\n  //   es: { 'app.name': 'TorchOne', 'app.tagline': 'Tu Asistente de IA' },\n  //   fr: { 'app.name': 'TorchOne', 'app.tagline': 'Votre Assistant IA' }\n  // }\n}\n\n// Example 4: Error handling and fallbacks\nexport async function getRobustTranslations(context: ApiContext, locale: Locale = 'en') {\n  const translations: TranslationObject[] = [\n    {\n      key: 'error.notFound',\n      fallback: 'Content not found'\n    },\n    {\n      key: 'error.serverError',\n      fallback: 'Server error occurred'\n    },\n    {\n      key: 'success.saved',\n      fallback: 'Content saved successfully'\n    }\n  ];\n\n  try {\n    const result = await i18n(context, translations, locale);\n    return result;\n  } catch(error) {\n    console.error('Translation error:', error);\n    // Return fallbacks if translation fails\n    return translations.reduce((acc, t) => {\n      acc[t.key] = t.fallback || '';\n      return acc;\n    }, {} as Record<string, string>);\n  }\n}\n\n// Example 5: Batch processing with flush\nexport async function processLargeTranslationBatch(context: ApiContext, locale: Locale = 'en') {\n  // Create a large batch of translations\n  const translations: TranslationObject[] = [];\n\n  for(let i = 1; i <= 100; i++) {\n    translations.push({\n      key: `item.${i}.title`,\n      fallback: `Item ${i} Title`,\n      params: {number: i}\n    });\n  }\n\n  // Process the batch\n  const result = await i18n(context, translations, locale);\n\n  // Ensure all pending translations are processed\n  await flush();\n\n  return result;\n}\n\n// Example 6: Error handling with fallbacks\nexport async function getErrorMessages(context: ApiContext, errorCode: string, locale: Locale = 'en') {\n  const translations: TranslationObject[] = [\n    {\n      key: `error.${errorCode}`,\n      fallback: `An error occurred: ${errorCode}`,\n      params: {errorCode}\n    },\n    {\n      key: 'error.contactSupport',\n      fallback: 'Please contact support if this problem persists.',\n      params: {}\n    }\n  ];\n\n  const result = await i18n(context, translations, locale);\n\n  // If database is unavailable, will return fallbacks:\n  // {\n  //   'error.INVALID_EMAIL': 'An error occurred: INVALID_EMAIL',\n  //   'error.contactSupport': 'Please contact support if this problem persists.'\n  // }\n\n  return result;\n}\n\n// Example 7: Complex email template with multiple interpolations\nexport async function generateEmailTemplate(\n  context: ApiContext,\n  userData: {\n    name: string;\n    email: string;\n    orderId: string;\n    total: number;\n    items: number;\n  },\n  locale: Locale = 'en'\n) {\n  const translations: TranslationObject[] = [\n    {\n      key: 'email.orderConfirmation.subject',\n      fallback: 'Order {{orderId}} Confirmed',\n      params: {orderId: userData.orderId}\n    },\n    {\n      key: 'email.orderConfirmation.greeting',\n      fallback: 'Hello {{name}},',\n      params: {name: userData.name}\n    },\n    {\n      key: 'email.orderConfirmation.body',\n      fallback: 'Your order {{orderId}} has been confirmed. Total: ${{total}} for {{items}} items.',\n      params: {\n        orderId: userData.orderId,\n        total: userData.total,\n        items: userData.items\n      }\n    },\n    {\n      key: 'email.orderConfirmation.footer',\n      fallback: 'Thank you for your purchase!'\n    }\n  ];\n\n  const result = await i18n(context, translations, locale);\n\n  return {\n    subject: result['email.orderConfirmation.subject'],\n    greeting: result['email.orderConfirmation.greeting'],\n    body: result['email.orderConfirmation.body'],\n    footer: result['email.orderConfirmation.footer']\n  };\n}\n\n// Example 8: Notification messages for different scenarios\nexport async function getNotificationMessages(context: ApiContext, locale: Locale = 'en') {\n  const translations: TranslationObject[] = [\n    {\n      key: 'notification.welcome',\n      fallback: 'Welcome to TorchOne!'\n    },\n    {\n      key: 'notification.verification',\n      fallback: 'Please verify your account.'\n    },\n    {\n      key: 'notification.passwordReset',\n      fallback: 'Your password has been reset.'\n    },\n    {\n      key: 'notification.profileUpdate',\n      fallback: 'Your profile has been updated.'\n    },\n    {\n      key: 'notification.newMessage',\n      fallback: 'You have a new message from {{sender}}.',\n      params: {sender: 'John Doe'}\n    }\n  ];\n\n  const result = await i18n(context, translations, locale);\n\n  return result;\n}\n\n// Example 9: Performance comparison\nexport async function performanceComparison(context: ApiContext) {\n  const keys = [\n    'welcome', 'verification', 'passwordReset', 'profileUpdate',\n    'email.subject', 'email.body', 'sms.welcome', 'sms.verification'\n  ];\n\n  const translations: TranslationObject[] = keys.map((key) => ({\n    key,\n    fallback: `Fallback for ${key}`\n  }));\n\n  console.time('Batch translation');\n  const batchResults = await i18n(context, translations, 'en');\n  console.timeEnd('Batch translation');\n\n  return batchResults;\n}\n\n// Example 10: Dynamic content based on user preferences\nexport async function getUserGreeting(\n  context: ApiContext,\n  userLocale?: string,\n  username?: string\n) {\n  const locale: Locale = (userLocale as Locale) || 'en';\n\n  const translations: TranslationObject[] = [\n    {\n      key: 'greeting.morning',\n      fallback: 'Good morning!',\n      params: username ? {username} : {}\n    },\n    {\n      key: 'greeting.afternoon',\n      fallback: 'Good afternoon!',\n      params: username ? {username} : {}\n    },\n    {\n      key: 'greeting.evening',\n      fallback: 'Good evening!',\n      params: username ? {username} : {}\n    }\n  ];\n\n  const result = await i18n(context, translations, locale);\n\n  // Return appropriate greeting based on time of day\n  const hour = new Date().getHours();\n  if(hour < 12) {\n    return result['greeting.morning'];\n  }\n  if(hour < 18) {\n    return result['greeting.afternoon'];\n  }\n  return result['greeting.evening'];\n}\n\n// Example 11: Force flush pending translations\nexport async function ensureAllTranslationsProcessed() {\n  // Force process any pending translation batches\n  await flush();\n  console.log('All translation batches processed');\n}\n\n// Usage examples:\n// const context = { databaseName: 'torchone-dev', session: { userId: 'user123' } };\n//\n// // Basic usage\n// const welcomeMessages = await getWelcomeMessages(context, 'en');\n//\n// // With interpolation\n// const personalizedMessages = await getPersonalizedMessages(context, 'John', 'es');\n//\n// // Multi-language content\n// const multiLanguageContent = await getMultiLanguageContent(context);\n//\n// // Error handling\n// const errorMessages = await getRobustTranslations(context, 'de');\n//\n// // Complex template\n// const emailTemplate = await generateEmailTemplate(context, {\n//   name: 'Maria',\n//   email: 'maria@example.com',\n//   orderId: 'ORD-123',\n//   total: 99.99,\n//   items: 3\n// }, 'pt');\n//\n// // Notifications\n// const notifications = await getNotificationMessages(context, 'fr');\n//\n// // Performance test\n// const perf = await performanceComparison(context);\n//\n// // Dynamic greeting\n// const greeting = await getUserGreeting(context, 'en', 'John');\n//\n// // Force flush\n// await ensureAllTranslationsProcessed();"],"names":["flush","i18n","getWelcomeMessages","context","locale","translations","key","fallback","result","getPersonalizedMessages","username","params","count","date","Date","toLocaleDateString","getMultiLanguageContent","languages","results","getRobustTranslations","error","console","reduce","acc","t","processLargeTranslationBatch","i","push","number","getErrorMessages","errorCode","generateEmailTemplate","userData","orderId","name","total","items","subject","greeting","body","footer","getNotificationMessages","sender","performanceComparison","keys","map","time","batchResults","timeEnd","getUserGreeting","userLocale","hour","getHours","ensureAllTranslationsProcessed","log"],"mappings":"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"}

package/lib/utils/translationQueue.js

@@ -1,2 +1,113 @@
-import{getContentWithFallback as u}from"../actions/content.js";class m{batches=new Map;batchTimeout=50;maxBatchSize=20;async translate(e,t,n="en"){if(t.length===0)return{};const o=t.map(({key:r,fallback:i="",params:l={}})=>this.getTranslation(e,r,i,l,n)),s=await Promise.all(o),a={};return t.forEach(({key:r},i)=>{a[r]=s[i]}),a}async getTranslation(e,t,n,o={},s="en"){return new Promise((a,r)=>{const i=this.getBatchKey(e,s),l={key:t,fallback:n,params:o,locale:s,resolve:a,reject:r};if(this.batches.has(i)){const c=this.batches.get(i);c.requests.push(l),c.requests.length>=this.maxBatchSize&&(clearTimeout(c.timeout),this.processBatch(i))}else{const c=setTimeout(()=>{this.processBatch(i)},this.batchTimeout);this.batches.set(i,{context:e,requests:[l],timeout:c})}})}async flush(){const e=Array.from(this.batches.keys());await Promise.all(e.map(t=>this.processBatch(t)))}clear(){this.batches.forEach(e=>{clearTimeout(e.timeout),e.requests.forEach(t=>{t.reject(new Error("Translation queue cleared"))})}),this.batches.clear()}getBatchKey(e,t){return`${e.databaseName}:${t}`}async processBatch(e){const t=this.batches.get(e);if(!t)return;this.batches.delete(e),clearTimeout(t.timeout);const n=t.requests.map(async s=>{try{const a=await u(t.context,s.key,s.fallback,s.locale),r=this.interpolate(a,s.params);return{request:s,result:r}}catch{const r=this.interpolate(s.fallback,s.params);return{request:s,result:r}}});(await Promise.allSettled(n)).forEach(s=>{if(s.status==="fulfilled")s.value.request.resolve(s.value.result);else{const{request:a}=s.reason,r=this.interpolate(a.fallback,a.params);a.resolve(r)}})}interpolate(e,t={}){return e.replace(/\{\{(\w+)\}\}/g,(n,o)=>t[o]!==void 0?String(t[o]):n)}}const h=new m,f=(p,e,t)=>h.translate(p,e,t),b=()=>h.flush(),d=()=>h.clear();export{d as clear,b as flush,f as i18n,h as translationQueue};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/utils/translationQueue.ts"],
  "sourcesContent": ["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\n\nimport {getContentWithFallback} from '../actions/content.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {Locale} from '../types/content.types.js';\n\ninterface TranslationRequest {\n  key: string;\n  fallback: string;\n  params?: Record<string, any>;\n  locale: Locale;\n  resolve: (value: string) => void;\n  reject: (error: Error) => void;\n}\n\ninterface TranslationBatch {\n  context: ApiContext;\n  requests: TranslationRequest[];\n  timeout: NodeJS.Timeout;\n}\n\ninterface TranslationObject {\n  key: string;\n  fallback?: string;\n  params?: Record<string, any>;\n}\n\nclass TranslationQueue {\n  private batches: Map<string, TranslationBatch> = new Map();\n  private batchTimeout = 50;\n  private maxBatchSize = 20;\n\n  async translate(\n    context: ApiContext,\n    translations: TranslationObject[],\n    locale: Locale = 'en'\n  ): Promise<Record<string, string>> {\n    if(translations.length === 0) {\n      return {};\n    }\n\n    const promises = translations.map(({key, fallback = '', params = {}}) =>\n      this.getTranslation(context, key, fallback, params, locale)\n    );\n\n    const results = await Promise.all(promises);\n\n    const resultMap: Record<string, string> = {};\n    translations.forEach(({key}, index) => {\n      resultMap[key] = results[index];\n    });\n\n    return resultMap;\n  }\n\n  private async getTranslation(\n    context: ApiContext,\n    key: string,\n    fallback: string,\n    params: Record<string, any> = {},\n    locale: Locale = 'en'\n  ): Promise<string> {\n    return new Promise((resolve, reject) => {\n      const batchKey = this.getBatchKey(context, locale);\n      const request: TranslationRequest = {key, fallback, params, locale, resolve, reject};\n\n      if(!this.batches.has(batchKey)) {\n        const timeout = setTimeout(() => {\n          this.processBatch(batchKey);\n        }, this.batchTimeout);\n\n        this.batches.set(batchKey, {\n          context,\n          requests: [request],\n          timeout\n        });\n      } else {\n        const batch = this.batches.get(batchKey)!;\n        batch.requests.push(request);\n\n        if(batch.requests.length >= this.maxBatchSize) {\n          clearTimeout(batch.timeout);\n          this.processBatch(batchKey);\n        }\n      }\n    });\n  }\n\n  async flush(): Promise<void> {\n    const batchKeys = Array.from(this.batches.keys());\n    await Promise.all(batchKeys.map((key) => this.processBatch(key)));\n  }\n\n  clear(): void {\n    this.batches.forEach((batch) => {\n      clearTimeout(batch.timeout);\n      batch.requests.forEach((request) => {\n        request.reject(new Error('Translation queue cleared'));\n      });\n    });\n    this.batches.clear();\n  }\n\n  private getBatchKey(context: ApiContext, locale: Locale): string {\n    return `${context.databaseName}:${locale}`;\n  }\n\n  private async processBatch(batchKey: string): Promise<void> {\n    const batch = this.batches.get(batchKey);\n    if(!batch) {\n      return;\n    }\n\n    this.batches.delete(batchKey);\n    clearTimeout(batch.timeout);\n\n    const promises = batch.requests.map(async (request) => {\n      try {\n        const content = await getContentWithFallback(\n          batch.context,\n          request.key,\n          request.fallback,\n          request.locale\n        );\n\n        const interpolatedContent = this.interpolate(content, request.params);\n        return {request, result: interpolatedContent};\n      } catch(error) {\n        const interpolatedFallback = this.interpolate(request.fallback, request.params);\n        return {request, result: interpolatedFallback};\n      }\n    });\n\n    const results = await Promise.allSettled(promises);\n\n    results.forEach((result) => {\n      if(result.status === 'fulfilled') {\n        result.value.request.resolve(result.value.result);\n      } else {\n        const {request} = result.reason;\n        const interpolatedFallback = this.interpolate(request.fallback, request.params);\n        request.resolve(interpolatedFallback);\n      }\n    });\n  }\n\n  private interpolate(content: string, params: Record<string, any> = {}): string {\n    return content.replace(/\\{\\{(\\w+)\\}\\}/g, (match, key) => (params[key] !== undefined ? String(params[key]) : match));\n  }\n}\n\nconst translationQueue = new TranslationQueue();\n\nexport const i18n = (\n  context: ApiContext,\n  translations: TranslationObject[],\n  locale?: Locale\n): Promise<Record<string, string>> => translationQueue.translate(context, translations, locale);\n\nexport const flush = (): Promise<void> => translationQueue.flush();\nexport const clear = (): void => translationQueue.clear();\n\nexport type {TranslationObject};\n\n  export {translationQueue};\n"],
  "mappings": "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",
  "names": ["getContentWithFallback", "TranslationQueue", "context", "translations", "locale", "promises", "key", "fallback", "params", "results", "resultMap", "index", "resolve", "reject", "batchKey", "request", "batch", "timeout", "batchKeys", "content", "interpolatedContent", "interpolatedFallback", "result", "match", "translationQueue", "i18n", "flush", "clear"]
}

+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { getContentWithFallback } from '../actions/content.js';
+class TranslationQueue {
+    batches = new Map();
+    batchTimeout = 50;
+    maxBatchSize = 20;
+    async translate(context, translations, locale = 'en') {
+        if (translations.length === 0) {
+            return {};
+        }
+        const promises = translations.map(({ key, fallback = '', params = {} })=>this.getTranslation(context, key, fallback, params, locale));
+        const results = await Promise.all(promises);
+        const resultMap = {};
+        translations.forEach(({ key }, index)=>{
+            resultMap[key] = results[index];
+        });
+        return resultMap;
+    }
+    async getTranslation(context, key, fallback, params = {}, locale = 'en') {
+        return new Promise((resolve, reject)=>{
+            const batchKey = this.getBatchKey(context, locale);
+            const request = {
+                key,
+                fallback,
+                params,
+                locale,
+                resolve,
+                reject
+            };
+            if (!this.batches.has(batchKey)) {
+                const timeout = setTimeout(()=>{
+                    this.processBatch(batchKey);
+                }, this.batchTimeout);
+                this.batches.set(batchKey, {
+                    context,
+                    requests: [
+                        request
+                    ],
+                    timeout
+                });
+            } else {
+                const batch = this.batches.get(batchKey);
+                batch.requests.push(request);
+                if (batch.requests.length >= this.maxBatchSize) {
+                    clearTimeout(batch.timeout);
+                    this.processBatch(batchKey);
+                }
+            }
+        });
+    }
+    async flush() {
+        const batchKeys = Array.from(this.batches.keys());
+        await Promise.all(batchKeys.map((key)=>this.processBatch(key)));
+    }
+    clear() {
+        this.batches.forEach((batch)=>{
+            clearTimeout(batch.timeout);
+            batch.requests.forEach((request)=>{
+                request.reject(new Error('Translation queue cleared'));
+            });
+        });
+        this.batches.clear();
+    }
+    getBatchKey(context, locale) {
+        return `${context.databaseName}:${locale}`;
+    }
+    async processBatch(batchKey) {
+        const batch = this.batches.get(batchKey);
+        if (!batch) {
+            return;
+        }
+        this.batches.delete(batchKey);
+        clearTimeout(batch.timeout);
+        const promises = batch.requests.map(async (request)=>{
+            try {
+                const content = await getContentWithFallback(batch.context, request.key, request.fallback, request.locale);
+                const interpolatedContent = this.interpolate(content, request.params);
+                return {
+                    request,
+                    result: interpolatedContent
+                };
+            } catch (error) {
+                const interpolatedFallback = this.interpolate(request.fallback, request.params);
+                return {
+                    request,
+                    result: interpolatedFallback
+                };
+            }
+        });
+        const results = await Promise.allSettled(promises);
+        results.forEach((result)=>{
+            if (result.status === 'fulfilled') {
+                result.value.request.resolve(result.value.result);
+            } else {
+                const { request } = result.reason;
+                const interpolatedFallback = this.interpolate(request.fallback, request.params);
+                request.resolve(interpolatedFallback);
+            }
+        });
+    }
+    interpolate(content, params = {}) {
+        return content.replace(/\{\{(\w+)\}\}/g, (match, key)=>params[key] !== undefined ? String(params[key]) : match);
+    }
+}
+const translationQueue = new TranslationQueue();
+export const i18n = (context, translations, locale)=>translationQueue.translate(context, translations, locale);
+export const flush = ()=>translationQueue.flush();
+export const clear = ()=>translationQueue.clear();
+export { translationQueue };
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/utils/translationQueue.ts"],"sourcesContent":["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\n\nimport {getContentWithFallback} from '../actions/content.js';\n\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {Locale} from '../types/content.types.js';\n\ninterface TranslationRequest {\n  key: string;\n  fallback: string;\n  params?: Record<string, any>;\n  locale: Locale;\n  resolve: (value: string) => void;\n  reject: (error: Error) => void;\n}\n\ninterface TranslationBatch {\n  context: ApiContext;\n  requests: TranslationRequest[];\n  timeout: NodeJS.Timeout;\n}\n\ninterface TranslationObject {\n  key: string;\n  fallback?: string;\n  params?: Record<string, any>;\n}\n\nclass TranslationQueue {\n  private batches: Map<string, TranslationBatch> = new Map();\n  private batchTimeout = 50;\n  private maxBatchSize = 20;\n\n  async translate(\n    context: ApiContext,\n    translations: TranslationObject[],\n    locale: Locale = 'en'\n  ): Promise<Record<string, string>> {\n    if(translations.length === 0) {\n      return {};\n    }\n\n    const promises = translations.map(({key, fallback = '', params = {}}) =>\n      this.getTranslation(context, key, fallback, params, locale)\n    );\n\n    const results = await Promise.all(promises);\n\n    const resultMap: Record<string, string> = {};\n    translations.forEach(({key}, index) => {\n      resultMap[key] = results[index];\n    });\n\n    return resultMap;\n  }\n\n  private async getTranslation(\n    context: ApiContext,\n    key: string,\n    fallback: string,\n    params: Record<string, any> = {},\n    locale: Locale = 'en'\n  ): Promise<string> {\n    return new Promise((resolve, reject) => {\n      const batchKey = this.getBatchKey(context, locale);\n      const request: TranslationRequest = {key, fallback, params, locale, resolve, reject};\n\n      if(!this.batches.has(batchKey)) {\n        const timeout = setTimeout(() => {\n          this.processBatch(batchKey);\n        }, this.batchTimeout);\n\n        this.batches.set(batchKey, {\n          context,\n          requests: [request],\n          timeout\n        });\n      } else {\n        const batch = this.batches.get(batchKey)!;\n        batch.requests.push(request);\n\n        if(batch.requests.length >= this.maxBatchSize) {\n          clearTimeout(batch.timeout);\n          this.processBatch(batchKey);\n        }\n      }\n    });\n  }\n\n  async flush(): Promise<void> {\n    const batchKeys = Array.from(this.batches.keys());\n    await Promise.all(batchKeys.map((key) => this.processBatch(key)));\n  }\n\n  clear(): void {\n    this.batches.forEach((batch) => {\n      clearTimeout(batch.timeout);\n      batch.requests.forEach((request) => {\n        request.reject(new Error('Translation queue cleared'));\n      });\n    });\n    this.batches.clear();\n  }\n\n  private getBatchKey(context: ApiContext, locale: Locale): string {\n    return `${context.databaseName}:${locale}`;\n  }\n\n  private async processBatch(batchKey: string): Promise<void> {\n    const batch = this.batches.get(batchKey);\n    if(!batch) {\n      return;\n    }\n\n    this.batches.delete(batchKey);\n    clearTimeout(batch.timeout);\n\n    const promises = batch.requests.map(async (request) => {\n      try {\n        const content = await getContentWithFallback(\n          batch.context,\n          request.key,\n          request.fallback,\n          request.locale\n        );\n\n        const interpolatedContent = this.interpolate(content, request.params);\n        return {request, result: interpolatedContent};\n      } catch(error) {\n        const interpolatedFallback = this.interpolate(request.fallback, request.params);\n        return {request, result: interpolatedFallback};\n      }\n    });\n\n    const results = await Promise.allSettled(promises);\n\n    results.forEach((result) => {\n      if(result.status === 'fulfilled') {\n        result.value.request.resolve(result.value.result);\n      } else {\n        const {request} = result.reason;\n        const interpolatedFallback = this.interpolate(request.fallback, request.params);\n        request.resolve(interpolatedFallback);\n      }\n    });\n  }\n\n  private interpolate(content: string, params: Record<string, any> = {}): string {\n    return content.replace(/\\{\\{(\\w+)\\}\\}/g, (match, key) => (params[key] !== undefined ? String(params[key]) : match));\n  }\n}\n\nconst translationQueue = new TranslationQueue();\n\nexport const i18n = (\n  context: ApiContext,\n  translations: TranslationObject[],\n  locale?: Locale\n): Promise<Record<string, string>> => translationQueue.translate(context, translations, locale);\n\nexport const flush = (): Promise<void> => translationQueue.flush();\nexport const clear = (): void => translationQueue.clear();\n\nexport type {TranslationObject};\n\n  export {translationQueue};\n"],"names":["getContentWithFallback","TranslationQueue","batches","Map","batchTimeout","maxBatchSize","translate","context","translations","locale","length","promises","map","key","fallback","params","getTranslation","results","Promise","all","resultMap","forEach","index","resolve","reject","batchKey","getBatchKey","request","has","timeout","setTimeout","processBatch","set","requests","batch","get","push","clearTimeout","flush","batchKeys","Array","from","keys","clear","Error","databaseName","delete","content","interpolatedContent","interpolate","result","error","interpolatedFallback","allSettled","status","value","reason","replace","match","undefined","String","translationQueue","i18n"],"mappings":"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"}