@seniorsistemas/components-ai 0.0.0-master-d4a804fe

package/esm2022/lib/services/senior-token.service.mjs

@@ -0,0 +1,209 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./cookie.service";
+/**
+ * Serviço para gerenciar o token Senior e extrair informações específicas
+ * para o sistema de traduções.
+ *
+ * Nota: Este serviço foca especificamente na extração do locale e informações
+ * básicas do usuário. Para funcionalidades completas de autenticação,
+ * use o AuthService que tem uma interface mais robusta.
+ */
+export class SeniorTokenService {
+    cookieService;
+    SENIOR_TOKEN_COOKIE = 'com.senior.token';
+    constructor(cookieService) {
+        this.cookieService = cookieService;
+    }
+    /**
+     * Obtém o token Senior completo do cookie
+     */
+    getSeniorToken() {
+        // Tentar o nome padrão primeiro
+        let token = this.cookieService.getCookie(this.SENIOR_TOKEN_COOKIE);
+        if (!token) {
+            // Tentar nomes alternativos comuns
+            const alternativeNames = [
+                'com.senior.token',
+                'senior.token',
+                'senior_token',
+                'seniorToken',
+                'token',
+                'authToken',
+                'auth_token'
+            ];
+            for (const name of alternativeNames) {
+                token = this.cookieService.getCookie(name);
+                if (token) {
+                    break;
+                }
+            }
+        }
+        return token;
+    }
+    /**
+     * Decodifica e obtém os dados do token Senior
+     */
+    getSeniorTokenData() {
+        const token = this.getSeniorToken();
+        if (!token) {
+            return null;
+        }
+        try {
+            let tokenData;
+            // Primeiro, tentar como JSON direto (mais provável baseado na informação fornecida)
+            try {
+                tokenData = JSON.parse(token);
+            }
+            catch (jsonError) {
+                // Se falhar, tentar como JWT
+                if (token.includes('.')) {
+                    const parts = token.split('.');
+                    if (parts.length >= 2) {
+                        const payload = parts[1];
+                        // Adicionar padding se necessário
+                        const paddedPayload = payload + '='.repeat((4 - payload.length % 4) % 4);
+                        const decodedPayload = atob(paddedPayload);
+                        tokenData = JSON.parse(decodedPayload);
+                    }
+                    else {
+                        throw new Error('Invalid JWT format');
+                    }
+                }
+                else {
+                    throw jsonError; // Re-throw original JSON error
+                }
+            }
+            return tokenData;
+        }
+        catch (error) {
+            console.error('[SeniorTokenService] Error parsing Senior token:', error);
+            return null;
+        }
+    }
+    /**
+     * Obtém o locale do usuário do token Senior
+     */
+    getUserLocale() {
+        const tokenData = this.getSeniorTokenData();
+        if (!tokenData) {
+            return null;
+        }
+        // O locale deve estar no mesmo nível do access_token
+        if (tokenData.locale) {
+            return tokenData.locale;
+        }
+        // Fallback: tentar outros campos comuns
+        const possibleLocaleFields = [
+            'language',
+            'lang',
+            'user_locale',
+            'userLocale',
+            'preferred_language',
+            'preferredLanguage'
+        ];
+        for (const field of possibleLocaleFields) {
+            if (tokenData[field]) {
+                return tokenData[field];
+            }
+        }
+        return null;
+    }
+    /**
+     * Obtém informações do usuário do token Senior
+     */
+    getUserInfo() {
+        const tokenData = this.getSeniorTokenData();
+        if (!tokenData) {
+            return null;
+        }
+        // Baseado na estrutura do AuthService, os campos devem estar no nível raiz
+        return {
+            userId: tokenData.userId || tokenData['sub'] || tokenData['user_id'] || tokenData.username,
+            userName: tokenData.userName || tokenData['name'] || tokenData['user_name'] || tokenData.username || tokenData.fullName,
+            locale: tokenData.locale,
+            email: tokenData.email,
+            fullName: tokenData.fullName
+        };
+    }
+    /**
+     * Verifica se o usuário está logado (token existe e é válido)
+     */
+    isUserLoggedIn() {
+        const tokenData = this.getSeniorTokenData();
+        if (!tokenData) {
+            return false;
+        }
+        // Verificar expiração se existir
+        if (tokenData['exp']) {
+            const now = Math.floor(Date.now() / 1000);
+            if (tokenData['exp'] < now) {
+                console.warn('Senior token has expired');
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Monitora mudanças no cookie do token (para detectar login/logout)
+     */
+    watchTokenChanges(callback) {
+        let lastToken = this.getSeniorToken();
+        const checkToken = () => {
+            const currentToken = this.getSeniorToken();
+            if (currentToken !== lastToken) {
+                lastToken = currentToken;
+                const tokenData = this.getSeniorTokenData();
+                callback(tokenData);
+            }
+        };
+        // Verificar a cada 5 segundos
+        setInterval(checkToken, 5000);
+    }
+    /**
+     * Valida se o token tem a estrutura esperada do Senior
+     */
+    validateTokenStructure() {
+        const tokenData = this.getSeniorTokenData();
+        const issues = [];
+        if (!tokenData) {
+            issues.push('Token not found or could not be parsed');
+            return { isValid: false, issues };
+        }
+        // Verificar campos obrigatórios esperados
+        const requiredFields = ['access_token'];
+        const recommendedFields = ['locale', 'username', 'email'];
+        for (const field of requiredFields) {
+            if (!tokenData[field]) {
+                issues.push(`Missing required field: ${field}`);
+            }
+        }
+        for (const field of recommendedFields) {
+            if (!tokenData[field]) {
+                issues.push(`Missing recommended field: ${field}`);
+            }
+        }
+        // Verificar se locale está presente e é válido
+        if (tokenData.locale) {
+            // Importar a função de mapeamento seria circular, então fazer verificação básica
+            const supportedLocales = ['pt-BR', 'en-US', 'es-ES', 'pt', 'en', 'es'];
+            const locale = tokenData.locale;
+            const isSupported = supportedLocales.some(supportedLocale => locale.toLowerCase().includes(supportedLocale.toLowerCase()));
+            if (!isSupported) {
+                issues.push(`Locale '${locale}' might not be supported`);
+            }
+        }
+        const isValid = issues.filter(issue => issue.includes('required')).length === 0;
+        console.log('[SeniorTokenService] Token validation result:', { isValid, issues });
+        return { isValid, issues };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SeniorTokenService, deps: [{ token: i1.CookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SeniorTokenService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SeniorTokenService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.CookieService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"senior-token.service.js","sourceRoot":"","sources":["../../../../projects/components-ai/src/lib/services/senior-token.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { CookieService } from './cookie.service';\n\nexport interface SeniorTokenData {\n  locale?: string;\n  userId?: string;\n  userName?: string;\n  access_token?: string;\n  expires_in?: number;\n  refresh_token?: string;\n  token_type?: string;\n  refresh_expires_in?: number;\n  username?: string;\n  email?: string;\n  fullName?: string;\n  tenantName?: string;\n  type?: string;\n  [key: string]: any;\n}\n\n/**\n * Serviço para gerenciar o token Senior e extrair informações específicas\n * para o sistema de traduções.\n * \n * Nota: Este serviço foca especificamente na extração do locale e informações\n * básicas do usuário. Para funcionalidades completas de autenticação,\n * use o AuthService que tem uma interface mais robusta.\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class SeniorTokenService {\n  private readonly SENIOR_TOKEN_COOKIE = 'com.senior.token';\n\n  constructor(private cookieService: CookieService) {}\n\n  /**\n   * Obtém o token Senior completo do cookie\n   */\n  getSeniorToken(): string | null {\n    // Tentar o nome padrão primeiro\n    let token = this.cookieService.getCookie(this.SENIOR_TOKEN_COOKIE);\n    \n    if (!token) {\n      // Tentar nomes alternativos comuns\n      const alternativeNames = [\n        'com.senior.token',\n        'senior.token',\n        'senior_token',\n        'seniorToken',\n        'token',\n        'authToken',\n        'auth_token'\n      ];\n      \n      for (const name of alternativeNames) {\n        token = this.cookieService.getCookie(name);\n        if (token) {\n          break;\n        }\n      }\n    }\n    \n    return token;\n  }\n\n  /**\n   * Decodifica e obtém os dados do token Senior\n   */\n  getSeniorTokenData(): SeniorTokenData | null {\n    const token = this.getSeniorToken();\n    \n    if (!token) {\n      return null;\n    }\n\n    try {\n      let tokenData: any;\n      \n      // Primeiro, tentar como JSON direto (mais provável baseado na informação fornecida)\n      try {\n        tokenData = JSON.parse(token);\n      } catch (jsonError) {\n        // Se falhar, tentar como JWT\n        if (token.includes('.')) {\n          const parts = token.split('.');\n          if (parts.length >= 2) {\n            const payload = parts[1];\n            // Adicionar padding se necessário\n            const paddedPayload = payload + '='.repeat((4 - payload.length % 4) % 4);\n            const decodedPayload = atob(paddedPayload);\n            tokenData = JSON.parse(decodedPayload);\n          } else {\n            throw new Error('Invalid JWT format');\n          }\n        } else {\n          throw jsonError; // Re-throw original JSON error\n        }\n      }\n\n      return tokenData as SeniorTokenData;\n    } catch (error) {\n      console.error('[SeniorTokenService] Error parsing Senior token:', error);\n      return null;\n    }\n  }\n\n  /**\n   * Obtém o locale do usuário do token Senior\n   */\n  getUserLocale(): string | null {\n    const tokenData = this.getSeniorTokenData();\n    \n    if (!tokenData) {\n      return null;\n    }\n\n    // O locale deve estar no mesmo nível do access_token\n    if (tokenData.locale) {\n      return tokenData.locale;\n    }\n\n    // Fallback: tentar outros campos comuns\n    const possibleLocaleFields = [\n      'language', \n      'lang',\n      'user_locale',\n      'userLocale',\n      'preferred_language',\n      'preferredLanguage'\n    ];\n\n    for (const field of possibleLocaleFields) {\n      if (tokenData[field]) {\n        return tokenData[field];\n      }\n    }\n    \n    return null;\n  }\n\n  /**\n   * Obtém informações do usuário do token Senior\n   */\n  getUserInfo(): { userId?: string; userName?: string; locale?: string; email?: string; fullName?: string } | null {\n    const tokenData = this.getSeniorTokenData();\n    \n    if (!tokenData) {\n      return null;\n    }\n\n    // Baseado na estrutura do AuthService, os campos devem estar no nível raiz\n    return {\n      userId: tokenData.userId || tokenData['sub'] || tokenData['user_id'] || tokenData.username,\n      userName: tokenData.userName || tokenData['name'] || tokenData['user_name'] || tokenData.username || tokenData.fullName,\n      locale: tokenData.locale,\n      email: tokenData.email,\n      fullName: tokenData.fullName\n    };\n  }\n\n  /**\n   * Verifica se o usuário está logado (token existe e é válido)\n   */\n  isUserLoggedIn(): boolean {\n    const tokenData = this.getSeniorTokenData();\n    \n    if (!tokenData) {\n      return false;\n    }\n\n    // Verificar expiração se existir\n    if (tokenData['exp']) {\n      const now = Math.floor(Date.now() / 1000);\n      if (tokenData['exp'] < now) {\n        console.warn('Senior token has expired');\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Monitora mudanças no cookie do token (para detectar login/logout)\n   */\n  watchTokenChanges(callback: (tokenData: SeniorTokenData | null) => void): void {\n    let lastToken = this.getSeniorToken();\n    \n    const checkToken = () => {\n      const currentToken = this.getSeniorToken();\n      \n      if (currentToken !== lastToken) {\n        lastToken = currentToken;\n        const tokenData = this.getSeniorTokenData();\n        callback(tokenData);\n      }\n    };\n\n    // Verificar a cada 5 segundos\n    setInterval(checkToken, 5000);\n  }\n\n  /**\n   * Valida se o token tem a estrutura esperada do Senior\n   */\n  validateTokenStructure(): { isValid: boolean; issues: string[] } {\n    const tokenData = this.getSeniorTokenData();\n    const issues: string[] = [];\n    \n    if (!tokenData) {\n      issues.push('Token not found or could not be parsed');\n      return { isValid: false, issues };\n    }\n    \n    // Verificar campos obrigatórios esperados\n    const requiredFields = ['access_token'];\n    const recommendedFields = ['locale', 'username', 'email'];\n    \n    for (const field of requiredFields) {\n      if (!tokenData[field]) {\n        issues.push(`Missing required field: ${field}`);\n      }\n    }\n    \n    for (const field of recommendedFields) {\n      if (!tokenData[field]) {\n        issues.push(`Missing recommended field: ${field}`);\n      }\n    }\n    \n    // Verificar se locale está presente e é válido\n    if (tokenData.locale) {\n      // Importar a função de mapeamento seria circular, então fazer verificação básica\n      const supportedLocales = ['pt-BR', 'en-US', 'es-ES', 'pt', 'en', 'es'];\n      const locale = tokenData.locale;\n      const isSupported = supportedLocales.some(supportedLocale => \n        locale.toLowerCase().includes(supportedLocale.toLowerCase())\n      );\n      \n      if (!isSupported) {\n        issues.push(`Locale '${locale}' might not be supported`);\n      }\n    }\n    \n    const isValid = issues.filter(issue => issue.includes('required')).length === 0;\n    \n    console.log('[SeniorTokenService] Token validation result:', { isValid, issues });\n    \n    return { isValid, issues };\n  }\n}\n"]}

package/esm2022/lib/services/theme.service.mjs

@@ -0,0 +1,85 @@
+import { Injectable, Inject } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class ThemeService {
+    document;
+    isDarkModeSubject = new BehaviorSubject(false);
+    isDarkMode$ = this.isDarkModeSubject.asObservable();
+    mediaQuery;
+    constructor(document) {
+        this.document = document;
+        // Create media query to watch for system theme changes (kept for compatibility)
+        this.mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
+        // Check for saved theme preference, default to light theme
+        const savedTheme = localStorage.getItem('theme');
+        if (savedTheme === 'dark') {
+            // Only use dark theme if explicitly saved as dark
+            this.setTheme(true);
+        }
+        else {
+            // Default to light theme, ignoring system preference
+            this.setTheme(false);
+            // Set default theme preference if not exists
+            if (!savedTheme) {
+                localStorage.setItem('theme', 'light');
+            }
+        }
+    }
+    followSystemTheme() {
+        // This method is kept for compatibility but no longer used by default
+        // Set theme based on system preference only when explicitly requested
+        this.setTheme(this.mediaQuery.matches);
+        // Listen for system theme changes only when in auto mode
+        this.mediaQuery.addEventListener('change', (e) => {
+            const savedTheme = localStorage.getItem('theme');
+            if (savedTheme === 'auto') {
+                this.setTheme(e.matches);
+            }
+        });
+    }
+    toggleTheme() {
+        const currentTheme = this.isDarkModeSubject.value;
+        this.setTheme(!currentTheme);
+        // When manually toggling, save the specific preference
+        localStorage.setItem('theme', !currentTheme ? 'dark' : 'light');
+    }
+    setThemeMode(mode) {
+        localStorage.setItem('theme', mode);
+        if (mode === 'auto') {
+            this.followSystemTheme();
+        }
+        else {
+            this.setTheme(mode === 'dark');
+        }
+    }
+    setTheme(isDark) {
+        this.isDarkModeSubject.next(isDark);
+        // Apply theme to document
+        if (isDark) {
+            this.document.documentElement.classList.add('app-dark');
+        }
+        else {
+            this.document.documentElement.classList.remove('app-dark');
+        }
+    }
+    get isDarkMode() {
+        return this.isDarkModeSubject.value;
+    }
+    get currentThemeMode() {
+        const savedTheme = localStorage.getItem('theme');
+        return savedTheme || 'light'; // Default to light instead of auto
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ThemeService, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ThemeService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ThemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/translation.service.mjs

@@ -0,0 +1,232 @@
+import { Injectable, Optional, Inject } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { TRANSLATION_CONFIG, mapTokenLocaleToLanguage } from '../config/translation.config';
+import * as i0 from "@angular/core";
+import * as i1 from "./senior-token.service";
+export class TranslationService {
+    seniorTokenService;
+    currentLanguage = new BehaviorSubject(TRANSLATION_CONFIG.defaultLanguage);
+    translations = {};
+    loadingLanguages = new Set();
+    translationLoader;
+    constructor(seniorTokenService, loader) {
+        this.seniorTokenService = seniorTokenService;
+        this.translationLoader = loader;
+        this.loadStoredLanguage();
+        // Carregar traduções do idioma inicial imediatamente
+        this.loadTranslations();
+        // Monitorar mudanças no token para atualizar idioma
+        this.watchTokenChanges();
+    }
+    get currentLanguage$() {
+        return this.currentLanguage.asObservable();
+    }
+    getCurrentLanguage() {
+        return this.currentLanguage.value;
+    }
+    async setLanguage(language) {
+        this.currentLanguage.next(language);
+        localStorage.setItem(TRANSLATION_CONFIG.storageKey, language);
+        await this.loadTranslations();
+    }
+    async waitForTranslations() {
+        const language = this.currentLanguage.value;
+        if (!this.isLanguageLoaded(language)) {
+            await this.loadTranslations();
+        }
+    }
+    /**
+     * Verifica se as traduções do idioma atual estão carregadas
+     */
+    isLanguageLoaded(language) {
+        const lang = language || this.currentLanguage.value;
+        return !!this.translations[lang] && Object.keys(this.translations[lang]).length > 0;
+    }
+    translate(key, params) {
+        const currentLang = this.currentLanguage.value;
+        const translations = this.translations[currentLang];
+        if (!translations || Object.keys(translations).length === 0) {
+            // Se as traduções não estão carregadas, tentar carregar de forma assíncrona
+            if (!this.loadingLanguages.has(currentLang)) {
+                this.loadTranslations().catch(error => {
+                    console.error('Error loading translations:', error);
+                });
+            }
+            console.warn(`No translations loaded for language: ${currentLang}`);
+            return key;
+        }
+        // Para estrutura plana, buscar diretamente pela chave
+        const translation = translations[key];
+        if (!translation) {
+            console.warn(`Translation key not found: ${key}`);
+            return key;
+        }
+        if (typeof translation !== 'string') {
+            console.warn(`Translation key is not a string: ${key}`);
+            return key;
+        }
+        // Replace parameters if provided
+        if (params) {
+            return this.replaceParams(translation, params);
+        }
+        return translation;
+    }
+    async loadTranslations() {
+        const language = this.currentLanguage.value;
+        // Se já está carregado, não carregar novamente
+        if (this.isLanguageLoaded(language)) {
+            return;
+        }
+        // Evitar carregamentos duplicados
+        if (this.loadingLanguages.has(language)) {
+            // Aguardar um pouco e tentar novamente
+            await new Promise(resolve => setTimeout(resolve, 100));
+            if (this.isLanguageLoaded(language)) {
+                return;
+            }
+        }
+        this.loadingLanguages.add(language);
+        try {
+            await this.doLoadTranslations(language);
+        }
+        catch (error) {
+            console.error('Error in loadTranslations:', error);
+        }
+        finally {
+            this.loadingLanguages.delete(language);
+        }
+    }
+    async doLoadTranslations(language) {
+        try {
+            // Se há um loader customizado, usar ele
+            if (this.translationLoader) {
+                const translations = await this.translationLoader.loadTranslations(language);
+                this.translations[language] = translations;
+                console.log(`Translations loaded for ${language}:`, Object.keys(this.translations[language]).length, 'keys');
+                return;
+            }
+            // Caso contrário, avisar que não há traduções
+            console.warn(`No translation loader provided. Translations for ${language} not loaded.`);
+            this.translations[language] = {};
+        }
+        catch (error) {
+            console.error(`Error loading translations for ${language}:`, error);
+            // Fallback para o idioma padrão se houver erro
+            if (language !== TRANSLATION_CONFIG.fallbackLanguage) {
+                try {
+                    if (this.translationLoader) {
+                        const fallbackTranslations = await this.translationLoader.loadTranslations(TRANSLATION_CONFIG.fallbackLanguage);
+                        this.translations[language] = fallbackTranslations;
+                        console.log(`Fallback translations loaded for ${language}`);
+                    }
+                }
+                catch (fallbackError) {
+                    console.error(`Error loading fallback translations:`, fallbackError);
+                }
+            }
+        }
+    }
+    loadStoredLanguage() {
+        // 1. Primeiro, tentar obter do token Senior
+        const tokenLocale = this.seniorTokenService.getUserLocale();
+        if (tokenLocale) {
+            const mappedLanguage = mapTokenLocaleToLanguage(tokenLocale);
+            if (mappedLanguage) {
+                console.log(`Using language from Senior token: ${tokenLocale} -> ${mappedLanguage}`);
+                this.currentLanguage.next(mappedLanguage);
+                return;
+            }
+        }
+        // 2. Segundo, tentar obter do localStorage
+        const stored = localStorage.getItem(TRANSLATION_CONFIG.storageKey);
+        const supportedCodes = TRANSLATION_CONFIG.supportedLanguages.map(lang => lang.code);
+        if (stored && supportedCodes.includes(stored)) {
+            console.log('Using language from localStorage:', stored);
+            this.currentLanguage.next(stored);
+            return;
+        }
+        // 3. Por último, usar idioma padrão
+        console.log('Using default language:', TRANSLATION_CONFIG.defaultLanguage);
+        this.currentLanguage.next(TRANSLATION_CONFIG.defaultLanguage);
+    }
+    replaceParams(text, params) {
+        return text.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+            return params[key] !== undefined ? params[key] : match;
+        });
+    }
+    getSupportedLanguages() {
+        return TRANSLATION_CONFIG.supportedLanguages;
+    }
+    /**
+     * Força o recarregamento das traduções (útil para desenvolvimento)
+     */
+    async reloadTranslations() {
+        const language = this.currentLanguage.value;
+        delete this.translations[language];
+        await this.loadTranslations();
+    }
+    /**
+     * Obtém todas as chaves de tradução carregadas
+     */
+    getLoadedKeys() {
+        const language = this.currentLanguage.value;
+        const translations = this.translations[language];
+        return translations ? Object.keys(translations) : [];
+    }
+    /**
+     * Verifica se um código de idioma é suportado
+     */
+    isValidLanguage(locale) {
+        const supportedCodes = TRANSLATION_CONFIG.supportedLanguages.map(lang => lang.code);
+        return supportedCodes.includes(locale);
+    }
+    /**
+     * Monitora mudanças no token Senior para atualizar idioma automaticamente
+     */
+    watchTokenChanges() {
+        this.seniorTokenService.watchTokenChanges((tokenData) => {
+            if (tokenData?.locale) {
+                const mappedLanguage = mapTokenLocaleToLanguage(tokenData.locale);
+                if (mappedLanguage) {
+                    const newLocale = mappedLanguage;
+                    const currentLocale = this.currentLanguage.value;
+                    if (newLocale !== currentLocale) {
+                        console.log(`Token locale changed: ${tokenData.locale} -> ${newLocale}`);
+                        this.setLanguage(newLocale);
+                    }
+                }
+            }
+        });
+    }
+    /**
+     * Força atualização do idioma baseado no token atual
+     */
+    async syncWithToken() {
+        const tokenLocale = this.seniorTokenService.getUserLocale();
+        if (tokenLocale) {
+            const mappedLanguage = mapTokenLocaleToLanguage(tokenLocale);
+            if (mappedLanguage) {
+                const newLocale = mappedLanguage;
+                const currentLocale = this.currentLanguage.value;
+                if (newLocale !== currentLocale) {
+                    console.log(`Syncing language with token: ${tokenLocale} -> ${newLocale}`);
+                    await this.setLanguage(newLocale);
+                }
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TranslationService, deps: [{ token: i1.SeniorTokenService }, { token: 'TranslationLoader', optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TranslationService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: TranslationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.SeniorTokenService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: ['TranslationLoader']
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translation.service.js","sourceRoot":"","sources":["../../../../projects/components-ai/src/lib/services/translation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Optional, Inject } from '@angular/core';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { TRANSLATION_CONFIG, LanguageConfig, mapTokenLocaleToLanguage } from '../config/translation.config';\nimport { SeniorTokenService } from './senior-token.service';\n\nexport type SupportedLanguage = 'pt-BR' | 'en-US' | 'es-ES';\n\n// Interface para o loader de traduções (duck typing)\nexport interface TranslationLoader {\n  loadTranslations(language: string): Promise<any>;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class TranslationService {\n  private currentLanguage = new BehaviorSubject<SupportedLanguage>(\n    TRANSLATION_CONFIG.defaultLanguage as SupportedLanguage\n  );\n  private translations: { [key: string]: any } = {};\n  private loadingLanguages = new Set<string>();\n  private translationLoader?: TranslationLoader;\n\n  constructor(\n    private seniorTokenService: SeniorTokenService,\n    @Optional() @Inject('TranslationLoader') loader?: TranslationLoader\n  ) {\n    this.translationLoader = loader;\n    this.loadStoredLanguage();\n    // Carregar traduções do idioma inicial imediatamente\n    this.loadTranslations();\n    \n    // Monitorar mudanças no token para atualizar idioma\n    this.watchTokenChanges();\n  }\n\n  get currentLanguage$(): Observable<SupportedLanguage> {\n    return this.currentLanguage.asObservable();\n  }\n\n  getCurrentLanguage(): SupportedLanguage {\n    return this.currentLanguage.value;\n  }\n\n  async setLanguage(language: SupportedLanguage): Promise<void> {\n    this.currentLanguage.next(language);\n    localStorage.setItem(TRANSLATION_CONFIG.storageKey, language);\n    await this.loadTranslations();\n  }\n\n  async waitForTranslations(): Promise<void> {\n    const language = this.currentLanguage.value;\n    if (!this.isLanguageLoaded(language)) {\n      await this.loadTranslations();\n    }\n  }\n\n  /**\n   * Verifica se as traduções do idioma atual estão carregadas\n   */\n  isLanguageLoaded(language?: SupportedLanguage): boolean {\n    const lang = language || this.currentLanguage.value;\n    return !!this.translations[lang] && Object.keys(this.translations[lang]).length > 0;\n  }\n\n  translate(key: string, params?: { [key: string]: any }): string {\n    const currentLang = this.currentLanguage.value;\n    const translations = this.translations[currentLang];\n    \n    if (!translations || Object.keys(translations).length === 0) {\n      // Se as traduções não estão carregadas, tentar carregar de forma assíncrona\n      if (!this.loadingLanguages.has(currentLang)) {\n        this.loadTranslations().catch(error => {\n          console.error('Error loading translations:', error);\n        });\n      }\n      console.warn(`No translations loaded for language: ${currentLang}`);\n      return key;\n    }\n\n    // Para estrutura plana, buscar diretamente pela chave\n    const translation = translations[key];\n    \n    if (!translation) {\n      console.warn(`Translation key not found: ${key}`);\n      return key;\n    }\n\n    if (typeof translation !== 'string') {\n      console.warn(`Translation key is not a string: ${key}`);\n      return key;\n    }\n\n    // Replace parameters if provided\n    if (params) {\n      return this.replaceParams(translation, params);\n    }\n\n    return translation;\n  }\n\n  private async loadTranslations(): Promise<void> {\n    const language = this.currentLanguage.value;\n    \n    // Se já está carregado, não carregar novamente\n    if (this.isLanguageLoaded(language)) {\n      return;\n    }\n    \n    // Evitar carregamentos duplicados\n    if (this.loadingLanguages.has(language)) {\n      // Aguardar um pouco e tentar novamente\n      await new Promise(resolve => setTimeout(resolve, 100));\n      if (this.isLanguageLoaded(language)) {\n        return;\n      }\n    }\n    \n    this.loadingLanguages.add(language);\n    \n    try {\n      await this.doLoadTranslations(language);\n    } catch (error) {\n      console.error('Error in loadTranslations:', error);\n    } finally {\n      this.loadingLanguages.delete(language);\n    }\n  }\n  \n  private async doLoadTranslations(language: SupportedLanguage): Promise<void> {\n    try {\n      // Se há um loader customizado, usar ele\n      if (this.translationLoader) {\n        const translations = await this.translationLoader.loadTranslations(language);\n        this.translations[language] = translations;\n        console.log(`Translations loaded for ${language}:`, Object.keys(this.translations[language]).length, 'keys');\n        return;\n      }\n      \n      // Caso contrário, avisar que não há traduções\n      console.warn(`No translation loader provided. Translations for ${language} not loaded.`);\n      this.translations[language] = {};\n    } catch (error) {\n      console.error(`Error loading translations for ${language}:`, error);\n      // Fallback para o idioma padrão se houver erro\n      if (language !== TRANSLATION_CONFIG.fallbackLanguage) {\n        try {\n          if (this.translationLoader) {\n            const fallbackTranslations = await this.translationLoader.loadTranslations(TRANSLATION_CONFIG.fallbackLanguage);\n            this.translations[language] = fallbackTranslations;\n            console.log(`Fallback translations loaded for ${language}`);\n          }\n        } catch (fallbackError) {\n          console.error(`Error loading fallback translations:`, fallbackError);\n        }\n      }\n    }\n  }\n\n  private loadStoredLanguage(): void {\n    // 1. Primeiro, tentar obter do token Senior\n    const tokenLocale = this.seniorTokenService.getUserLocale();\n    if (tokenLocale) {\n      const mappedLanguage = mapTokenLocaleToLanguage(tokenLocale);\n      if (mappedLanguage) {\n        console.log(`Using language from Senior token: ${tokenLocale} -> ${mappedLanguage}`);\n        this.currentLanguage.next(mappedLanguage as SupportedLanguage);\n        return;\n      }\n    }\n\n    // 2. Segundo, tentar obter do localStorage\n    const stored = localStorage.getItem(TRANSLATION_CONFIG.storageKey) as SupportedLanguage;\n    const supportedCodes = TRANSLATION_CONFIG.supportedLanguages.map(lang => lang.code);\n    if (stored && supportedCodes.includes(stored)) {\n      console.log('Using language from localStorage:', stored);\n      this.currentLanguage.next(stored);\n      return;\n    }\n\n    // 3. Por último, usar idioma padrão\n    console.log('Using default language:', TRANSLATION_CONFIG.defaultLanguage);\n    this.currentLanguage.next(TRANSLATION_CONFIG.defaultLanguage as SupportedLanguage);\n  }\n\n  private replaceParams(text: string, params: { [key: string]: any }): string {\n    return text.replace(/\\{\\{(\\w+)\\}\\}/g, (match, key) => {\n      return params[key] !== undefined ? params[key] : match;\n    });\n  }\n\n  getSupportedLanguages(): LanguageConfig[] {\n    return TRANSLATION_CONFIG.supportedLanguages;\n  }\n\n  /**\n   * Força o recarregamento das traduções (útil para desenvolvimento)\n   */\n  async reloadTranslations(): Promise<void> {\n    const language = this.currentLanguage.value;\n    delete this.translations[language];\n    await this.loadTranslations();\n  }\n\n  /**\n   * Obtém todas as chaves de tradução carregadas\n   */\n  getLoadedKeys(): string[] {\n    const language = this.currentLanguage.value;\n    const translations = this.translations[language];\n    return translations ? Object.keys(translations) : [];\n  }\n\n  /**\n   * Verifica se um código de idioma é suportado\n   */\n  private isValidLanguage(locale: string): boolean {\n    const supportedCodes = TRANSLATION_CONFIG.supportedLanguages.map(lang => lang.code);\n    return supportedCodes.includes(locale);\n  }\n\n  /**\n   * Monitora mudanças no token Senior para atualizar idioma automaticamente\n   */\n  private watchTokenChanges(): void {\n    this.seniorTokenService.watchTokenChanges((tokenData) => {\n      if (tokenData?.locale) {\n        const mappedLanguage = mapTokenLocaleToLanguage(tokenData.locale);\n        if (mappedLanguage) {\n          const newLocale = mappedLanguage as SupportedLanguage;\n          const currentLocale = this.currentLanguage.value;\n          \n          if (newLocale !== currentLocale) {\n            console.log(`Token locale changed: ${tokenData.locale} -> ${newLocale}`);\n            this.setLanguage(newLocale);\n          }\n        }\n      }\n    });\n  }\n\n  /**\n   * Força atualização do idioma baseado no token atual\n   */\n  async syncWithToken(): Promise<void> {\n    const tokenLocale = this.seniorTokenService.getUserLocale();\n    if (tokenLocale) {\n      const mappedLanguage = mapTokenLocaleToLanguage(tokenLocale);\n      if (mappedLanguage) {\n        const newLocale = mappedLanguage as SupportedLanguage;\n        const currentLocale = this.currentLanguage.value;\n        \n        if (newLocale !== currentLocale) {\n          console.log(`Syncing language with token: ${tokenLocale} -> ${newLocale}`);\n          await this.setLanguage(newLocale);\n        }\n      }\n    }\n  }\n}\n"]}