@po-ui/ng-components 5.22.0 → 6.0.0

package/esm2020/lib/services/po-i18n/po-i18n-base.service.mjs

@@ -0,0 +1,439 @@
+import { __decorate, __param } from "tslib";
+import { HttpClient } from '@angular/common/http';
+import { Inject } from '@angular/core';
+import { Observable } from 'rxjs';
+import { isLanguage, reloadCurrentPage } from '../../utils/util';
+import { I18N_CONFIG } from './po-i18n-config-injection-token';
+/**
+ * @description
+ *
+ * O serviço `PoI18nService` possibilita utilizar múltiplos idiomas e contextos na aplicação.
+ *
+ * > Antes da utilização do serviço, é necessário realizar a
+ * [importação e configuração do módulo `PoI18nModule`](/documentation/po-i18n#i18n-config).
+ *
+ * **Utilização do serviço `PoI18nService`:**
+ *
+ * Para utilizar o serviço basta importá-lo nos componentes que necessitarem de literais e fazer a injeção de
+ * dependência no construtor:
+ * ```
+ *  import { PoI18nService } from '@po-ui/ng-components';
+ *  ...
+ *  constructor(private poI18nService: PoI18nService) { }
+ *  ...
+ * ```
+ *
+ * Por fim realizar a busca pelas literais, inscrevendo-se no [Observable](https://angular.io/guide/observables) pelo
+ * método `getLiterals()`.
+ *
+ * > O método `getLiterals()` pode receber um objeto do tipo da interface `PoI18nLiterals` como parâmetro,
+ * porém, nenhuma das propriedades são obrigatórias. Caso nenhum parâmetro seja passado, serão buscadas
+ * todas as literais do contexto definido com padrão, no idioma definido como padrão.
+ *
+ * Exemplos de requisição:
+ * ```
+ * literals = {};
+ * literalsEn = {};
+ * literalsCrm = {};
+ *
+ * constructor(private poI18nService: PoI18nService) {
+ *   poI18nService.getLiterals()
+ *     .subscribe((literals) => {
+ *       this.literals = literals;
+ *     });
+ *
+ *   poI18nService.getLiterals({context: 'crm', literals: ['add', 'remove']})
+ *     .subscribe((literals) => {
+ *       this.literalsCrm = literals;
+ *     });
+ *
+ *   poI18nService.getLiterals({language: 'en-us'})
+ *     .subscribe((literals) => {
+ *       this.literalsEn = literals;
+ *     });
+ * }
+ * ```
+ *
+ * Para apresentar as literais capturadas acima no HTML do componente, deve-se utilizar o
+ * seguinte código:
+ *
+ * <pre ngNonBindable>
+ * {{ literals?.add }}
+ * {{ literals?.remove }}
+ * </pre>
+ *
+ * Caso as literais contenham variáveis que precisem ser substituídas, pode-se utilizar o *pipe* `poI18n`.
+ * É possível informar propriedades do componente como `name` e `nickname` ou
+ * informar o valor diretamente com "" ou número, conforme o exemplo abaixo:
+ *
+ * <pre ngNonBindable>
+ * {{ literals?.people | poI18n:[120] }}
+ * {{ literals?.greeting | poI18n:[name, nickname] }}
+ * {{ literals?.greeting | poI18n:["Brad", "Green"] }}
+ * </pre>
+ *
+ * > É importante o uso do operador `?` (Elvis) para evitar erros enquanto as literais não forem carregadas.
+ *
+ * ### Teste unitário
+ *
+ * Abaixo segue um exemplo de *setup* inicial de teste unitário do *AppComponent* que utiliza o `PoI18nService`:
+ *
+ * > Atenção: não declarar o `PoI18nService` no providers do TestBed pois a biblioteca realiza a injeção de dependência de forma dinâmica.
+ * > Se o serviço for declarado o teste não fará a injeção e o teste apresentará erros.
+ *
+ * ```
+ * import { async, TestBed } from '@angular/core/testing';
+ * import { HttpClientTestingModule } from '@angular/common/http/testing';
+ *
+ * import { PoI18nModule } from '@po-ui/ng-components';
+ *
+ * import { AppComponent } from './app.component';
+ *
+ * describe('AppComponent', () => {
+ *   const anotherPT = {
+ *     text: 'texto',
+ *     add: 'adicionar',
+ *     remove: 'remover'
+ *   };
+ *
+ *   const generalPT = {
+ *     text: 'texto',
+ *     add: 'adicionar',
+ *     remove: 'remover'
+ *   };
+ *
+ *   const config = {
+ *     default: {
+ *       language: 'pt-BR',
+ *       context: 'general',
+ *       cache: false
+ *     },
+ *     contexts: {
+ *       general: {
+ *         'pt-br': generalPT
+ *       },
+ *       another: {
+ *         'pt-br': anotherPT
+ *       }
+ *     }
+ *   };
+ *
+ *   beforeEach(async(() => {
+ *     TestBed.configureTestingModule({
+ *       declarations: [
+ *         AppComponent
+ *       ],
+ *       imports: [
+ *         HttpClientTestingModule,
+ *         PoI18nModule.config(config)
+ *       ]
+ *     }).compileComponents();
+ *   }));
+ *
+ *   it('should create the app', async(() => {
+ *     const fixture = TestBed.createComponent(AppComponent);
+ *     const app = fixture.debugElement.componentInstance;
+ *
+ *     expect(app).toBeTruthy();
+ *   }));
+ *
+ * });
+ * ```
+ */
+let PoI18nBaseService = class PoI18nBaseService {
+    constructor(config, http, languageService) {
+        this.config = config;
+        this.http = http;
+        this.languageService = languageService;
+        this.varI18n = {};
+        this.useCache = false;
+        this.servicesContext = {};
+        this.setConfig(config);
+    }
+    /**
+     * <a id="get-language"></a>
+     * Método que retorna o idioma padrão ativo.
+     *
+     * A busca deste idioma pelo método será feita na seguinte ordem:
+     *
+     *   1 - o idioma que foi armazenado no *localStorage*, através do método [`setLanguage()`](documentation/po-i18n#setLanguage).
+     *
+     *   2 - o valor inserido no módulo do i18n através do parâmetro `config`, sendo o idioma inserido na propriedade
+     * `language` da interface [`PoI18nConfigDefault`](documentation/po-i18n#poI18nConfigDefault).
+     *
+     *   3 - o idioma do navegador utilizado.
+     *
+     * > Caso o idioma do navegador não seja suportado pelo PO (`pt`, `en`, `es` ou `ru`), será retornado valor `pt`.
+     *
+     * @returns {string} sigla do idioma padrão.
+     */
+    getLanguage() {
+        return this.languageService.getLanguage();
+    }
+    getLiterals(options = {}) {
+        const language = options['language'] ? options['language'].toLowerCase() : this.getLanguage();
+        const context = options['context'] ? options['context'] : this.contextDefault;
+        const literals = options['literals'] ? options['literals'] : [];
+        return new Observable(observer => {
+            if (this.servicesContext[context]) {
+                // Faz o processo de busca de um contexto que contém serviço
+                this.getLiteralsFromContextService(language, context, literals, observer);
+            }
+            else {
+                // Faz o processo de busca de um contexto que utiliza constante
+                this.getLiteralsFromContextConstant(language, context, literals, observer);
+            }
+        });
+    }
+    /**
+     * Método que retorna o idioma padrão ativo, com somente a abreviação do idioma (duas primeiras letras).
+     * Por exemplo: "pt" ou "es".
+     *
+     * A busca deste idioma é baseada no método [**getLanguage()**](/documentation/po-i18n#get-language).
+     *
+     * @returns {string} sigla do idioma padrão.
+     */
+    getShortLanguage() {
+        return this.languageService.getShortLanguage();
+    }
+    /**
+     * <a id="setLanguage"></a>
+     * Método para alterar o idioma padrão do módulo do i18n.
+     *
+     * Ao utilizar este método, o idioma ficará gravado no armazenamento local do navegador, que será utilizado pelo
+     * serviço do `i18n` para buscar as literais no idioma padrão.
+     *
+     * @param {string} language Sigla do idioma.
+     *
+     * Esta sigla deve ser composta por duas letras representando o idioma,
+     * podendo ser adicionado outras duas letras representando o país, por exemplo: `pt`, `pt-BR`, `pt-br`, `en` ou `en-US`.
+     *
+     * > Caso seja informado um valor diferente deste padrão, o mesmo será ignorado.
+     *
+     * @param {boolean} reload Indica se a página atual poderá ser recarregada após a alteração do idioma.
+     *
+     * Este recurso pode ser útil para os usuários que utilizam o método `getLiterals()` do serviço do i18n para poder
+     * buscar novamente as literais no novo idioma configurado.
+     */
+    setLanguage(language, reload = false) {
+        if (!isLanguage(language)) {
+            return;
+        }
+        this.languageService.setLanguage(language);
+        if (reload) {
+            reloadCurrentPage();
+        }
+    }
+    setConfig(config) {
+        // Seta as configurações padrões definidas no importação do módulo
+        if (config['default']) {
+            this.languageService.setLanguageDefault(config['default']['language']);
+            this.contextDefault = config['default']['context'] ? config['default']['context'] : '';
+            this.useCache = config['default']['cache'] ? config['default']['cache'] : false;
+        }
+        // Carrega a lista dos contextos e as contantes informadas
+        if (config['contexts']) {
+            this.setVarI18n(config['contexts']);
+            // Se nenhum contexto foi definido como padrão,
+            // então define o primeiro contexto
+            if (!this.contextDefault) {
+                for (const context in config['contexts']) {
+                    if (this.config['contexts'].hasOwnProperty(context)) {
+                        this.contextDefault = context;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    // Processo de busca de um contexto que contém serviço.
+    //    1 - Procura na variável I18n deste serviço
+    //    2 - Procura no local storage (Se o cache estiver definido como true na configuração do módulo)
+    //    3 - Dispara o serviço, mesmo que já tenha encontrado no local storage, para garantir a atualização
+    //    4 - Se nenhuma literal for encontrada, então busca em pt-br
+    getLiteralsFromContextService(language, context, literals, observer, translations = {}, languageAlternative = null) {
+        // Idioma usado para tentar buscar as literais faltantes
+        const languageSearch = languageAlternative ? languageAlternative : language;
+        translations = this.mergeObject(translations, this.searchInVarI18n(languageSearch, context, literals));
+        if (this.countObject(translations) > 0) {
+            observer.next(translations);
+        }
+        // realiza a busca no localStorage e em seguida no serviço
+        this.getLiteralsLocalStorageAndCache(languageSearch, context, literals, observer, translations, languageAlternative);
+    }
+    // Procura no local storage e em seguida no serviço
+    // Caso não encontre nem no serviço, recomeça a busca em pt-br
+    getLiteralsLocalStorageAndCache(language, context, literals, observer, translations, languageAlternative = null) {
+        const languageSearch = languageAlternative ? languageAlternative : language;
+        let translationTemp;
+        // Verifica se usa cache
+        if (this.useCache) {
+            translationTemp = this.searchInLocalStorage(languageSearch, context, literals);
+            if (this.countObject(translationTemp) > 0) {
+                this.updateVarI18n(language, context, translationTemp);
+                translations = this.mergeObject(translationTemp, translations);
+                observer.next(translations);
+            }
+        }
+        // Busca do Serviço
+        this.getHttpService(this.servicesContext[context], languageSearch, literals).subscribe(response => {
+            if (response) {
+                this.updateLocalStorage(language, context, response);
+                this.updateVarI18n(language, context, response);
+                translationTemp = this.searchInVarI18n(language, context, literals);
+                translations = this.mergeObject(translationTemp, translations);
+                observer.next(translations);
+            }
+            // Se não encontrou todas as literais pesquisadas no idioma
+            // Então refaz o processo procurando em português
+            if (literals.length > this.countObject(translations)) {
+                if (languageAlternative === 'pt-br') {
+                    // Se não encontrou nem em português, então retorna o nome das literais
+                    translations = this.completeFaultLiterals(language, context, literals, translations);
+                    this.updateLocalStorage(language, context, translations);
+                    this.updateVarI18n(language, context, translations);
+                    observer.next(translations);
+                }
+                else {
+                    this.getLiteralsFromContextService(language, context, literals, observer, translations, 'pt-br');
+                }
+            }
+        });
+    }
+    // Procura pela lista de literais
+    // Se não encontrar todas, procura em pt-br
+    getLiteralsFromContextConstant(language, context, literals, observer, translations = {}) {
+        translations = this.mergeObject(translations, this.searchInVarI18n(language, context, literals));
+        if (this.countObject(translations) > 0) {
+            observer.next(translations);
+        }
+        // Se foi pesquisado por literais
+        if (literals.length > 0) {
+            // Se não encontrou todas as literais pesquisadas no idioma, procura em português
+            if (literals.length > this.countObject(translations)) {
+                if (language === 'pt-br') {
+                    // Se não encontrou nem em português, então retorna o nome das literais
+                    translations = this.completeFaultLiterals(language, context, literals, translations);
+                    observer.next(translations);
+                }
+                else {
+                    this.getLiteralsFromContextConstant('pt-br', context, literals, observer, translations);
+                }
+            }
+        }
+        else {
+            // Se não encontrar nenhuma literal, procura em português
+            if (this.countObject(translations) === 0 && language !== 'pt-br') {
+                this.getLiteralsFromContextConstant('pt-br', context, literals, observer, translations);
+            }
+            // caso não informar literais e não houver tradução
+            observer.next(translations);
+            observer.complete();
+        }
+    }
+    // Busca pelas literais no local storage
+    searchInLocalStorage(language, context, literals) {
+        const translations = {};
+        if (literals.length > 0) {
+            for (let i = 0; i < literals.length; i++) {
+                const literal = literals[i];
+                const translation = localStorage.getItem(language + '-' + context + '-' + literal);
+                if (translation) {
+                    translations[literal] = translation;
+                }
+            }
+        }
+        return translations;
+    }
+    // Busca pelas literais na variável do serviço
+    searchInVarI18n(language, context, literals) {
+        let translations = {};
+        if (this.varI18n[language] && this.varI18n[language][context]) {
+            const content = this.varI18n[language][context];
+            if (literals.length > 0) {
+                // Busca as literais desejadas
+                for (let i = 0; i < literals.length; i++) {
+                    const literal = literals[i];
+                    if (content.hasOwnProperty(literal)) {
+                        translations[literal] = content[literal];
+                    }
+                }
+            }
+            else {
+                // Atribui todas as literais
+                translations = { ...content };
+            }
+        }
+        return translations;
+    }
+    // Atualiza o local storage
+    updateLocalStorage(language, context, data) {
+        if (this.useCache) {
+            for (const literal of Object.keys(data)) {
+                localStorage.setItem(language + '-' + context + '-' + literal, data[literal]);
+            }
+        }
+    }
+    // Atualiza a variável local com as literais com os objetos passados na configuração
+    setVarI18n(contexts) {
+        // Percorre os contextos
+        for (const context of Object.keys(contexts)) {
+            const contextContent = contexts[context];
+            // Percorre os idiomas dentro do contexto
+            for (const language of Object.keys(contextContent)) {
+                const languageContent = contextContent[language];
+                if (language === 'url') {
+                    this.servicesContext[context] = languageContent;
+                }
+                else {
+                    this.updateVarI18n(language, context, languageContent);
+                }
+            }
+        }
+    }
+    // Atualiza a variável local com as literais idioma e contexto
+    updateVarI18n(language, context, data) {
+        language = language.toLowerCase();
+        if (!this.varI18n[language]) {
+            this.varI18n[language] = { [context]: {} };
+        }
+        if (!this.varI18n[language][context]) {
+            this.varI18n[language][context] = {};
+        }
+        // Cria ou atualiza o contexto dentro do storage
+        this.varI18n[language][context] = this.mergeObject(data, this.varI18n[language][context]);
+    }
+    getHttpService(url, language, literals) {
+        let param = '?language=' + language;
+        if (literals.length > 0) {
+            param += '&literals=' + literals.join();
+        }
+        // Remove a barra final do endereço
+        url = url.replace(/\/$/, '');
+        return this.http.get(`${url}${param}`);
+    }
+    // Completa com o nome da literais, as que não foram encontradas
+    completeFaultLiterals(language, context, literals, translations) {
+        for (let i = 0; i < literals.length; i++) {
+            const literal = literals[i];
+            if (!translations[literal]) {
+                translations[literal] = literal;
+            }
+        }
+        return translations;
+    }
+    // Conta os atributos do objeto
+    countObject(obj) {
+        return Object.keys(obj).length;
+    }
+    // Faz o merge dos objetos, sempre dando preferência para o primeiro objeto de parâmetro
+    mergeObject(objPermanent, obj) {
+        return { ...obj, ...objPermanent };
+    }
+};
+PoI18nBaseService = __decorate([
+    __param(0, Inject(I18N_CONFIG)),
+    __param(1, Inject(HttpClient))
+], PoI18nBaseService);
+export { PoI18nBaseService };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"po-i18n-base.service.js","sourceRoot":"","sources":["../../../../../../projects/ui/src/lib/services/po-i18n/po-i18n-base.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Inject } from '@angular/core';\n\nimport { Observable } from 'rxjs';\n\nimport { isLanguage, reloadCurrentPage } from '../../utils/util';\nimport { PoLanguageService } from '../po-language/po-language.service';\n\nimport { I18N_CONFIG } from './po-i18n-config-injection-token';\nimport { PoI18nConfig } from './interfaces/po-i18n-config.interface';\nimport { PoI18nLiterals } from './interfaces/po-i18n-literals.interface';\n\n/**\n * @description\n *\n * O serviço `PoI18nService` possibilita utilizar múltiplos idiomas e contextos na aplicação.\n *\n * > Antes da utilização do serviço, é necessário realizar a\n * [importação e configuração do módulo `PoI18nModule`](/documentation/po-i18n#i18n-config).\n *\n * **Utilização do serviço `PoI18nService`:**\n *\n * Para utilizar o serviço basta importá-lo nos componentes que necessitarem de literais e fazer a injeção de\n * dependência no construtor:\n * ```\n *  import { PoI18nService } from '@po-ui/ng-components';\n *  ...\n *  constructor(private poI18nService: PoI18nService) { }\n *  ...\n * ```\n *\n * Por fim realizar a busca pelas literais, inscrevendo-se no [Observable](https://angular.io/guide/observables) pelo\n * método `getLiterals()`.\n *\n * > O método `getLiterals()` pode receber um objeto do tipo da interface `PoI18nLiterals` como parâmetro,\n * porém, nenhuma das propriedades são obrigatórias. Caso nenhum parâmetro seja passado, serão buscadas\n * todas as literais do contexto definido com padrão, no idioma definido como padrão.\n *\n * Exemplos de requisição:\n * ```\n * literals = {};\n * literalsEn = {};\n * literalsCrm = {};\n *\n * constructor(private poI18nService: PoI18nService) {\n *   poI18nService.getLiterals()\n *     .subscribe((literals) => {\n *       this.literals = literals;\n *     });\n *\n *   poI18nService.getLiterals({context: 'crm', literals: ['add', 'remove']})\n *     .subscribe((literals) => {\n *       this.literalsCrm = literals;\n *     });\n *\n *   poI18nService.getLiterals({language: 'en-us'})\n *     .subscribe((literals) => {\n *       this.literalsEn = literals;\n *     });\n * }\n * ```\n *\n * Para apresentar as literais capturadas acima no HTML do componente, deve-se utilizar o\n * seguinte código:\n *\n * <pre ngNonBindable>\n * {{ literals?.add }}\n * {{ literals?.remove }}\n * </pre>\n *\n * Caso as literais contenham variáveis que precisem ser substituídas, pode-se utilizar o *pipe* `poI18n`.\n * É possível informar propriedades do componente como `name` e `nickname` ou\n * informar o valor diretamente com \"\" ou número, conforme o exemplo abaixo:\n *\n * <pre ngNonBindable>\n * {{ literals?.people | poI18n:[120] }}\n * {{ literals?.greeting | poI18n:[name, nickname] }}\n * {{ literals?.greeting | poI18n:[\"Brad\", \"Green\"] }}\n * </pre>\n *\n * > É importante o uso do operador `?` (Elvis) para evitar erros enquanto as literais não forem carregadas.\n *\n * ### Teste unitário\n *\n * Abaixo segue um exemplo de *setup* inicial de teste unitário do *AppComponent* que utiliza o `PoI18nService`:\n *\n * > Atenção: não declarar o `PoI18nService` no providers do TestBed pois a biblioteca realiza a injeção de dependência de forma dinâmica.\n * > Se o serviço for declarado o teste não fará a injeção e o teste apresentará erros.\n *\n * ```\n * import { async, TestBed } from '@angular/core/testing';\n * import { HttpClientTestingModule } from '@angular/common/http/testing';\n *\n * import { PoI18nModule } from '@po-ui/ng-components';\n *\n * import { AppComponent } from './app.component';\n *\n * describe('AppComponent', () => {\n *   const anotherPT = {\n *     text: 'texto',\n *     add: 'adicionar',\n *     remove: 'remover'\n *   };\n *\n *   const generalPT = {\n *     text: 'texto',\n *     add: 'adicionar',\n *     remove: 'remover'\n *   };\n *\n *   const config = {\n *     default: {\n *       language: 'pt-BR',\n *       context: 'general',\n *       cache: false\n *     },\n *     contexts: {\n *       general: {\n *         'pt-br': generalPT\n *       },\n *       another: {\n *         'pt-br': anotherPT\n *       }\n *     }\n *   };\n *\n *   beforeEach(async(() => {\n *     TestBed.configureTestingModule({\n *       declarations: [\n *         AppComponent\n *       ],\n *       imports: [\n *         HttpClientTestingModule,\n *         PoI18nModule.config(config)\n *       ]\n *     }).compileComponents();\n *   }));\n *\n *   it('should create the app', async(() => {\n *     const fixture = TestBed.createComponent(AppComponent);\n *     const app = fixture.debugElement.componentInstance;\n *\n *     expect(app).toBeTruthy();\n *   }));\n *\n * });\n * ```\n */\n\nexport class PoI18nBaseService {\n  private varI18n: any = {};\n\n  private contextDefault: string;\n\n  private useCache: boolean = false;\n\n  private servicesContext: any = {};\n\n  constructor(\n    @Inject(I18N_CONFIG) private config?: PoI18nConfig,\n    @Inject(HttpClient) private http?: HttpClient,\n    private languageService?: PoLanguageService\n  ) {\n    this.setConfig(config);\n  }\n\n  /**\n   * <a id=\"get-language\"></a>\n   * Método que retorna o idioma padrão ativo.\n   *\n   * A busca deste idioma pelo método será feita na seguinte ordem:\n   *\n   *   1 - o idioma que foi armazenado no *localStorage*, através do método [`setLanguage()`](documentation/po-i18n#setLanguage).\n   *\n   *   2 - o valor inserido no módulo do i18n através do parâmetro `config`, sendo o idioma inserido na propriedade\n   * `language` da interface [`PoI18nConfigDefault`](documentation/po-i18n#poI18nConfigDefault).\n   *\n   *   3 - o idioma do navegador utilizado.\n   *\n   * > Caso o idioma do navegador não seja suportado pelo PO (`pt`, `en`, `es` ou `ru`), será retornado valor `pt`.\n   *\n   * @returns {string} sigla do idioma padrão.\n   */\n  getLanguage(): string {\n    return this.languageService.getLanguage();\n  }\n\n  getLiterals(options: PoI18nLiterals = {}): Observable<object> {\n    const language = options['language'] ? options['language'].toLowerCase() : this.getLanguage();\n    const context = options['context'] ? options['context'] : this.contextDefault;\n    const literals: Array<string> = options['literals'] ? options['literals'] : [];\n\n    return new Observable(observer => {\n      if (this.servicesContext[context]) {\n        // Faz o processo de busca de um contexto que contém serviço\n        this.getLiteralsFromContextService(language, context, literals, observer);\n      } else {\n        // Faz o processo de busca de um contexto que utiliza constante\n        this.getLiteralsFromContextConstant(language, context, literals, observer);\n      }\n    });\n  }\n\n  /**\n   * Método que retorna o idioma padrão ativo, com somente a abreviação do idioma (duas primeiras letras).\n   * Por exemplo: \"pt\" ou \"es\".\n   *\n   * A busca deste idioma é baseada no método [**getLanguage()**](/documentation/po-i18n#get-language).\n   *\n   * @returns {string} sigla do idioma padrão.\n   */\n  getShortLanguage(): string {\n    return this.languageService.getShortLanguage();\n  }\n\n  /**\n   * <a id=\"setLanguage\"></a>\n   * Método para alterar o idioma padrão do módulo do i18n.\n   *\n   * Ao utilizar este método, o idioma ficará gravado no armazenamento local do navegador, que será utilizado pelo\n   * serviço do `i18n` para buscar as literais no idioma padrão.\n   *\n   * @param {string} language Sigla do idioma.\n   *\n   * Esta sigla deve ser composta por duas letras representando o idioma,\n   * podendo ser adicionado outras duas letras representando o país, por exemplo: `pt`, `pt-BR`, `pt-br`, `en` ou `en-US`.\n   *\n   * > Caso seja informado um valor diferente deste padrão, o mesmo será ignorado.\n   *\n   * @param {boolean} reload Indica se a página atual poderá ser recarregada após a alteração do idioma.\n   *\n   * Este recurso pode ser útil para os usuários que utilizam o método `getLiterals()` do serviço do i18n para poder\n   * buscar novamente as literais no novo idioma configurado.\n   */\n  setLanguage(language: string, reload: boolean = false): void {\n    if (!isLanguage(language)) {\n      return;\n    }\n\n    this.languageService.setLanguage(language);\n\n    if (reload) {\n      reloadCurrentPage();\n    }\n  }\n\n  private setConfig(config: PoI18nConfig) {\n    // Seta as configurações padrões definidas no importação do módulo\n    if (config['default']) {\n      this.languageService.setLanguageDefault(config['default']['language']);\n\n      this.contextDefault = config['default']['context'] ? config['default']['context'] : '';\n      this.useCache = config['default']['cache'] ? config['default']['cache'] : false;\n    }\n\n    // Carrega a lista dos contextos e as contantes informadas\n    if (config['contexts']) {\n      this.setVarI18n(config['contexts']);\n\n      // Se nenhum contexto foi definido como padrão,\n      // então define o primeiro contexto\n      if (!this.contextDefault) {\n        for (const context in config['contexts']) {\n          if (this.config['contexts'].hasOwnProperty(context)) {\n            this.contextDefault = context;\n            break;\n          }\n        }\n      }\n    }\n  }\n\n  // Processo de busca de um contexto que contém serviço.\n  //    1 - Procura na variável I18n deste serviço\n  //    2 - Procura no local storage (Se o cache estiver definido como true na configuração do módulo)\n  //    3 - Dispara o serviço, mesmo que já tenha encontrado no local storage, para garantir a atualização\n  //    4 - Se nenhuma literal for encontrada, então busca em pt-br\n  private getLiteralsFromContextService(\n    language: string,\n    context: string,\n    literals: Array<string>,\n    observer: any,\n    translations: any = {},\n    languageAlternative: string = null\n  ) {\n    // Idioma usado para tentar buscar as literais faltantes\n    const languageSearch = languageAlternative ? languageAlternative : language;\n\n    translations = this.mergeObject(translations, this.searchInVarI18n(languageSearch, context, literals));\n\n    if (this.countObject(translations) > 0) {\n      observer.next(translations);\n    }\n\n    // realiza a busca no localStorage e em seguida no serviço\n    this.getLiteralsLocalStorageAndCache(\n      languageSearch,\n      context,\n      literals,\n      observer,\n      translations,\n      languageAlternative\n    );\n  }\n\n  // Procura no local storage e em seguida no serviço\n  // Caso não encontre nem no serviço, recomeça a busca em pt-br\n  private getLiteralsLocalStorageAndCache(\n    language: string,\n    context: string,\n    literals: Array<string>,\n    observer: any,\n    translations: any,\n    languageAlternative: string = null\n  ) {\n    const languageSearch = languageAlternative ? languageAlternative : language;\n    let translationTemp;\n    // Verifica se usa cache\n    if (this.useCache) {\n      translationTemp = this.searchInLocalStorage(languageSearch, context, literals);\n      if (this.countObject(translationTemp) > 0) {\n        this.updateVarI18n(language, context, translationTemp);\n        translations = this.mergeObject(translationTemp, translations);\n        observer.next(translations);\n      }\n    }\n\n    // Busca do Serviço\n    this.getHttpService(this.servicesContext[context], languageSearch, literals).subscribe(response => {\n      if (response) {\n        this.updateLocalStorage(language, context, response);\n        this.updateVarI18n(language, context, response);\n        translationTemp = this.searchInVarI18n(language, context, literals);\n        translations = this.mergeObject(translationTemp, translations);\n        observer.next(translations);\n      }\n\n      // Se não encontrou todas as literais pesquisadas no idioma\n      // Então refaz o processo procurando em português\n      if (literals.length > this.countObject(translations)) {\n        if (languageAlternative === 'pt-br') {\n          // Se não encontrou nem em português, então retorna o nome das literais\n          translations = this.completeFaultLiterals(language, context, literals, translations);\n          this.updateLocalStorage(language, context, translations);\n          this.updateVarI18n(language, context, translations);\n          observer.next(translations);\n        } else {\n          this.getLiteralsFromContextService(language, context, literals, observer, translations, 'pt-br');\n        }\n      }\n    });\n  }\n\n  // Procura pela lista de literais\n  // Se não encontrar todas, procura em pt-br\n  private getLiteralsFromContextConstant(\n    language: string,\n    context: string,\n    literals: Array<string>,\n    observer: any,\n    translations: any = {}\n  ) {\n    translations = this.mergeObject(translations, this.searchInVarI18n(language, context, literals));\n    if (this.countObject(translations) > 0) {\n      observer.next(translations);\n    }\n\n    // Se foi pesquisado por literais\n    if (literals.length > 0) {\n      // Se não encontrou todas as literais pesquisadas no idioma, procura em português\n      if (literals.length > this.countObject(translations)) {\n        if (language === 'pt-br') {\n          // Se não encontrou nem em português, então retorna o nome das literais\n          translations = this.completeFaultLiterals(language, context, literals, translations);\n          observer.next(translations);\n        } else {\n          this.getLiteralsFromContextConstant('pt-br', context, literals, observer, translations);\n        }\n      }\n    } else {\n      // Se não encontrar nenhuma literal, procura em português\n      if (this.countObject(translations) === 0 && language !== 'pt-br') {\n        this.getLiteralsFromContextConstant('pt-br', context, literals, observer, translations);\n      }\n\n      // caso não informar literais e não houver tradução\n      observer.next(translations);\n      observer.complete();\n    }\n  }\n\n  // Busca pelas literais no local storage\n  private searchInLocalStorage(language: string, context: string, literals: Array<string>): any {\n    const translations: any = {};\n\n    if (literals.length > 0) {\n      for (let i = 0; i < literals.length; i++) {\n        const literal = literals[i];\n        const translation = localStorage.getItem(language + '-' + context + '-' + literal);\n        if (translation) {\n          translations[literal] = translation;\n        }\n      }\n    }\n    return translations;\n  }\n\n  // Busca pelas literais na variável do serviço\n  private searchInVarI18n(language: string, context: string, literals: Array<string>): any {\n    let translations: any = {};\n\n    if (this.varI18n[language] && this.varI18n[language][context]) {\n      const content = this.varI18n[language][context];\n\n      if (literals.length > 0) {\n        // Busca as literais desejadas\n        for (let i = 0; i < literals.length; i++) {\n          const literal = literals[i];\n          if (content.hasOwnProperty(literal)) {\n            translations[literal] = content[literal];\n          }\n        }\n      } else {\n        // Atribui todas as literais\n        translations = { ...content };\n      }\n    }\n    return translations;\n  }\n\n  // Atualiza o local storage\n  private updateLocalStorage(language: string, context: string, data: any) {\n    if (this.useCache) {\n      for (const literal of Object.keys(data)) {\n        localStorage.setItem(language + '-' + context + '-' + literal, data[literal]);\n      }\n    }\n  }\n\n  // Atualiza a variável local com as literais com os objetos passados na configuração\n  private setVarI18n(contexts: Object) {\n    // Percorre os contextos\n    for (const context of Object.keys(contexts)) {\n      const contextContent = contexts[context];\n      // Percorre os idiomas dentro do contexto\n      for (const language of Object.keys(contextContent)) {\n        const languageContent = contextContent[language];\n        if (language === 'url') {\n          this.servicesContext[context] = languageContent;\n        } else {\n          this.updateVarI18n(language, context, languageContent);\n        }\n      }\n    }\n  }\n\n  // Atualiza a variável local com as literais idioma e contexto\n  private updateVarI18n(language: string, context: string, data: any) {\n    language = language.toLowerCase();\n\n    if (!this.varI18n[language]) {\n      this.varI18n[language] = { [context]: {} };\n    }\n    if (!this.varI18n[language][context]) {\n      this.varI18n[language][context] = {};\n    }\n\n    // Cria ou atualiza o contexto dentro do storage\n    this.varI18n[language][context] = this.mergeObject(data, this.varI18n[language][context]);\n  }\n\n  private getHttpService(url: string, language: string, literals: Array<string>) {\n    let param = '?language=' + language;\n    if (literals.length > 0) {\n      param += '&literals=' + literals.join();\n    }\n\n    // Remove a barra final do endereço\n    url = url.replace(/\\/$/, '');\n\n    return this.http.get(`${url}${param}`);\n  }\n\n  // Completa com o nome da literais, as que não foram encontradas\n  private completeFaultLiterals(language: string, context: string, literals: Array<string>, translations: any) {\n    for (let i = 0; i < literals.length; i++) {\n      const literal = literals[i];\n      if (!translations[literal]) {\n        translations[literal] = literal;\n      }\n    }\n    return translations;\n  }\n\n  // Conta os atributos do objeto\n  private countObject(obj: object) {\n    return Object.keys(obj).length;\n  }\n\n  // Faz o merge dos objetos, sempre dando preferência para o primeiro objeto de parâmetro\n  private mergeObject(objPermanent: any, obj: any) {\n    return { ...obj, ...objPermanent };\n  }\n}\n"]}