@intlayer/docs 5.5.8

package/pt/dictionary/condition.md

@@ -0,0 +1,213 @@
+# Conteúdo Condicional / Condição no Intlayer
+
+## Como a Condição Funciona
+
+No Intlayer, o conteúdo condicional é alcançado através da função `cond`, que mapeia condições específicas (tipicamente valores booleanos) para o conteúdo correspondente. Essa abordagem permite selecionar dinamicamente o conteúdo com base em uma condição fornecida. Quando integrado com React Intlayer ou Next Intlayer, o conteúdo apropriado é automaticamente escolhido de acordo com a condição fornecida em tempo de execução.
+
+## Configurando Conteúdo Condicional
+
+Para configurar conteúdo condicional no seu projeto Intlayer, crie um módulo de conteúdo que inclua suas definições condicionais. Abaixo estão exemplos em vários formatos.
+
+```typescript fileName="**/*.content.ts" contentDeclarationFormat="typescript"
+import { cond, type Dictionary } from "intlayer";
+
+const myConditionalContent = {
+  key: "my_key",
+  content: {
+    myCondition: cond({
+      true: "meu conteúdo quando é verdadeiro",
+      false: "meu conteúdo quando é falso",
+      fallback: "meu conteúdo quando a condição falha", // Opcional
+    }),
+  },
+} satisfies Dictionary;
+
+export default myConditionalContent;
+```
+
+```javascript fileName="**/*.content.mjs" contentDeclarationFormat="esm"
+import { cond } from "intlayer";
+
+/** @type {import('intlayer').Dictionary} */
+const myConditionalContent = {
+  key: "my_key",
+  content: {
+    myCondition: cond({
+      true: "meu conteúdo quando é verdadeiro",
+      false: "meu conteúdo quando é falso",
+      fallback: "meu conteúdo quando a condição falha", // Opcional
+    }),
+  },
+};
+
+export default myConditionalContent;
+```
+
+```javascript fileName="**/*.content.cjs" contentDeclarationFormat="commonjs"
+const { cond } = require("intlayer");
+
+/** @type {import('intlayer').Dictionary} */
+const myConditionalContent = {
+  key: "my_key",
+  content: {
+    myCondition: cond({
+      true: "meu conteúdo quando é verdadeiro",
+      false: "meu conteúdo quando é falso",
+      fallback: "meu conteúdo quando a condição falha", // Opcional
+    }),
+  },
+};
+
+module.exports = myConditionalContent;
+```
+
+```json5 fileName="**/*.content.json" contentDeclarationFormat="json"
+{
+  "$schema": "https://intlayer.org/schema.json",
+  "key": "my_key",
+  "content": {
+    "myCondition": {
+      "nodeType": "condition",
+      "condition": {
+        "true": "meu conteúdo quando é verdadeiro",
+        "false": "meu conteúdo quando é falso",
+        "fallback": "meu conteúdo quando a condição falha", // Opcional
+      },
+    },
+  },
+}
+```
+
+> Se nenhum fallback for declarado, a última chave declarada será tomada como fallback se a condição não for validada.
+
+## Usando Conteúdo Condicional com React Intlayer
+
+Para utilizar conteúdo condicional dentro de um componente React, importe e use o hook `useIntlayer` do pacote `react-intlayer`. Este hook busca o conteúdo para a chave especificada e permite que você passe uma condição para selecionar a saída apropriada.
+
+```tsx fileName="**/*.tsx" codeFormat="typescript"
+import type { FC } from "react";
+import { useIntlayer } from "react-intlayer";
+
+const ConditionalComponent: FC = () => {
+  const { myCondition } = useIntlayer("my_key");
+
+  return (
+    <div>
+      <p>
+        {
+          /* Saída: meu conteúdo quando é verdadeiro */
+          myCondition(true)
+        }
+      </p>
+      <p>
+        {
+          /* Saída: meu conteúdo quando é falso */
+          myCondition(false)
+        }
+      </p>
+      <p>
+        {
+          /* Saída: meu conteúdo quando a condição falha */
+          myCondition("")
+        }
+      </p>
+      <p>
+        {
+          /* Saída: meu conteúdo quando a condição falha */
+          myCondition(undefined)
+        }
+      </p>
+    </div>
+  );
+};
+
+export default ConditionalComponent;
+```
+
+```javascript fileName="**/*.mjx" codeFormat="esm"
+import { useIntlayer } from "react-intlayer";
+
+const ConditionalComponent = () => {
+  const { myCondition } = useIntlayer("my_key");
+
+  return (
+    <div>
+      <p>
+        {
+          /* Saída: meu conteúdo quando é verdadeiro */
+          myCondition(true)
+        }
+      </p>
+      <p>
+        {
+          /* Saída: meu conteúdo quando é falso */
+          myCondition(false)
+        }
+      </p>
+      <p>
+        {
+          /* Saída: meu conteúdo quando a condição falha */
+          myCondition("")
+        }
+      </p>
+      <p>
+        {
+          /* Saída: meu conteúdo quando a condição falha */
+          myCondition(undefined)
+        }
+      </p>
+    </div>
+  );
+};
+
+export default ConditionalComponent;
+```
+
+```javascript fileName="**/*.cjs" codeFormat="commonjs"
+const { useIntlayer } = require("react-intlayer");
+
+const ConditionalComponent = () => {
+  const { myCondition } = useIntlayer("my_key");
+
+  return (
+    <div>
+      <p>
+        {
+          /* Saída: meu conteúdo quando é verdadeiro */
+          myCondition(true)
+        }
+      </p>
+      <p>
+        {
+          /* Saída: meu conteúdo quando é falso */
+          myCondition(false)
+        }
+      </p>
+      <p>
+        {
+          /* Saída: meu conteúdo quando a condição falha */
+          myCondition("")
+        }
+      </p>
+      <p>
+        {
+          /* Saída: meu conteúdo quando a condição falha */
+          myCondition(undefined)
+        }
+      </p>
+    </div>
+  );
+};
+
+module.exports = ConditionalComponent;
+```
+
+## Recursos Adicionais
+
+Para informações mais detalhadas sobre configuração e uso, consulte os seguintes recursos:
+
+- [Documentação do Intlayer CLI](https://github.com/aymericzip/intlayer/blob/main/docs/pt/intlayer_cli.md)
+- [Documentação do React Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/pt/intlayer_with_create_react_app.md)
+- [Documentação do Next Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/pt/intlayer_with_nextjs_15.md)
+
+Esses recursos oferecem mais insights sobre a configuração e uso do Intlayer em diversos ambientes e frameworks.

package/pt/dictionary/content_extention_customization.md

@@ -0,0 +1,81 @@
+# Personalização de Extensões de Conteúdo
+
+## Extensões de Arquivos de Conteúdo
+
+O Intlayer permite que você personalize as extensões para os arquivos de declaração de conteúdo. Essa personalização oferece flexibilidade no gerenciamento de projetos em larga escala e ajuda a evitar conflitos com outros módulos.
+
+### Extensões Padrão
+
+Por padrão, o Intlayer monitora todos os arquivos com as seguintes extensões para declarações de conteúdo:
+
+- `.content.json`
+- `.content.ts`
+- `.content.tsx`
+- `.content.js`
+- `.content.jsx`
+- `.content.mjs`
+- `.content.mjx`
+- `.content.cjs`
+- `.content.cjx`
+
+Essas extensões padrão são adequadas para a maioria das aplicações. No entanto, quando você tem necessidades específicas, pode definir extensões personalizadas para otimizar o processo de construção e reduzir o risco de conflitos com outros componentes.
+
+### Personalizando Extensões de Conteúdo
+
+Para personalizar as extensões de arquivos que o Intlayer usa para identificar arquivos de declaração de conteúdo, você pode especificá-las no arquivo de configuração do Intlayer. Essa abordagem é benéfica para projetos em larga escala, onde limitar o escopo do processo de monitoramento melhora o desempenho da construção.
+
+Aqui está um exemplo de como definir extensões de conteúdo personalizadas na sua configuração:
+
+```typescript fileName="intlayer.config.ts" codeFormat="typescript"
+import type { IntlayerConfig } from "intlayer";
+
+const config: IntlayerConfig = {
+  content: {
+    fileExtensions: [".my_content.ts", ".my_content.tsx"], // Suas extensões personalizadas
+  },
+};
+
+export default config;
+```
+
+```javascript fileName="intlayer.config.mjs" codeFormat="esm"
+/** @type {import('intlayer').IntlayerConfig} */
+const config = {
+  content: {
+    fileExtensions: [".my_content.cjs", ".my_content.cjx"], // Suas extensões personalizadas
+  },
+};
+
+export default config;
+```
+
+```javascript fileName="intlayer.config.cjs" codeFormat="commonjs"
+/** @type {import('intlayer').IntlayerConfig} */
+const config = {
+  content: {
+    fileExtensions: [".my_content.mjs", ".my_content.mjx"], // Suas extensões personalizadas
+  },
+};
+
+module.exports = config;
+```
+
+Neste exemplo, a configuração especifica duas extensões personalizadas: `.my_content.ts` e `.my_content.tsx`. O Intlayer monitorará apenas arquivos com essas extensões para construir dicionários.
+
+### Benefícios das Extensões Personalizadas
+
+- **Desempenho de Construção**: Reduzir o escopo dos arquivos monitorados pode melhorar significativamente o desempenho da construção em projetos grandes.
+- **Evitar Conflitos**: Extensões personalizadas ajudam a evitar conflitos com outros arquivos JavaScript ou TypeScript no seu projeto.
+- **Organização**: Extensões personalizadas permitem organizar seus arquivos de declaração de conteúdo de acordo com as necessidades do seu projeto.
+
+### Diretrizes para Extensões Personalizadas
+
+Ao personalizar extensões de arquivos de conteúdo, mantenha as seguintes diretrizes em mente:
+
+- **Unicidade**: Escolha extensões que sejam únicas dentro do seu projeto para evitar conflitos.
+- **Nomenclatura Consistente**: Use convenções de nomenclatura consistentes para melhor legibilidade e manutenção do código.
+- **Evitar Extensões Comuns**: Evite usar extensões comuns como `.ts` ou `.js` para prevenir conflitos com outros módulos ou bibliotecas.
+
+## Conclusão
+
+Personalizar extensões de arquivos de conteúdo no Intlayer é um recurso valioso para otimizar o desempenho e evitar conflitos em aplicações de grande escala. Seguindo as diretrizes descritas nesta documentação, você pode gerenciar efetivamente suas declarações de conteúdo e garantir uma integração tranquila com outras partes do seu projeto.

package/pt/dictionary/enumeration.md

@@ -0,0 +1,221 @@
+# Enumeração / Pluralização
+
+## Como Funciona a Enumeração
+
+No Intlayer, a enumeração é realizada através da função `enu`, que mapeia chaves específicas para seu conteúdo correspondente. Essas chaves podem representar valores numéricos, intervalos ou identificadores personalizados. Quando usado com React Intlayer ou Next Intlayer, o conteúdo apropriado é automaticamente selecionado com base no locale da aplicação e nas regras definidas.
+
+## Configurando a Enumeração
+
+Para configurar a enumeração no seu projeto Intlayer, você precisa criar um módulo de conteúdo que inclua definições de enumeração. Aqui está um exemplo de uma enumeração simples para o número de carros:
+
+```typescript fileName="**/*.content.ts" contentDeclarationFormat="typescript"
+import { enu, type Dictionary } from "intlayer";
+
+const carEnumeration = {
+  key: "car_count",
+  content: {
+    numberOfCar: enu({
+      "<-1": "Menos de menos um carro",
+      "-1": "Menos um carro",
+      "0": "Nenhum carro",
+      "1": "Um carro",
+      ">5": "Alguns carros",
+      ">19": "Muitos carros",
+      "fallback": "Valor padrão", // Opcional
+    }),
+  },
+} satisfies Dictionary;
+
+export default carEnumeration;
+```
+
+```javascript fileName="**/*.content.mjs" contentDeclarationFormat="esm"
+import { enu } from "intlayer";
+
+/** @type {import('intlayer').Dictionary} */
+const carEnumeration = {
+  key: "car_count",
+  content: {
+    numberOfCar: enu({
+      "<-1": "Menos de menos um carro",
+      "-1": "Menos um carro",
+      "0": "Nenhum carro",
+      "1": "Um carro",
+      ">5": "Alguns carros",
+      ">19": "Muitos carros",
+      "fallback": "Valor padrão", // Opcional
+    }),
+  },
+};
+
+export default carEnumeration;
+```
+
+```javascript fileName="**/*.content.cjs" contentDeclarationFormat="commonjs"
+const { enu } = require("intlayer");
+
+/** @type {import('intlayer').Dictionary} */
+const carEnumeration = {
+  key: "car_count",
+  content: {
+    numberOfCar: enu({
+      "<-1": "Menos de menos um carro",
+      "-1": "Menos um carro",
+      "0": "Nenhum carro",
+      "1": "Um carro",
+      ">5": "Alguns carros",
+      ">19": "Muitos carros",
+      "fallback": "Valor padrão", // Opcional
+    }),
+  },
+};
+
+module.exports = carEnumeration;
+```
+
+```json fileName="**/*.content.json" contentDeclarationFormat="json"
+{
+  "$schema": "https://intlayer.org/schema.json",
+  "key": "car_count",
+  "content": {
+    "numberOfCar": {
+      "nodeType": "enumeration",
+      "enumeration": {
+        "<-1": "Menos de menos um carro",
+        "-1": "Menos um carro",
+        "0": "Nenhum carro",
+        "1": "Um carro",
+        ">5": "Alguns carros",
+        ">19": "Muitos carros",
+        "fallback": "Valor padrão" // Opcional
+      }
+    }
+  }
+}
+```
+
+Neste exemplo, `enu` mapeia várias condições para conteúdos específicos. Quando usado em um componente React, o Intlayer pode escolher automaticamente o conteúdo apropriado com base na variável fornecida.
+
+> A ordem de declaração é importante nas enumerações do Intlayer. A primeira declaração válida é a que será escolhida. Se várias condições se aplicarem, certifique-se de que estão ordenadas corretamente para evitar comportamentos inesperados.
+
+> Se nenhum fallback for declarado, a função retornará `undefined` se nenhuma chave corresponder.
+
+## Usando Enumeração com React Intlayer
+
+Para usar enumeração em um componente React, você pode utilizar o hook `useIntlayer` do pacote `react-intlayer`. Este hook recupera o conteúdo correto com base no ID especificado. Aqui está um exemplo de como usá-lo:
+
+```tsx fileName="**/*.tsx" codeFormat="typescript"
+import type { FC } from "react";
+import { useIntlayer } from "react-intlayer";
+
+const CarComponent: FC = () => {
+  const { numberOfCar } = useIntlayer("car_count");
+
+  return (
+    <div>
+      <p>
+        {
+          numberOfCar(0) // Saída: Nenhum carro
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(6) // Saída: Alguns carros
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(20) // Saída: Muitos carros
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(0.01) // Saída: Valor padrão
+        }
+      </p>
+    </div>
+  );
+};
+```
+
+```javascript fileName="**/*.mjx" codeFormat="esm"
+import { useIntlayer } from "react-intlayer";
+
+const CarComponent = () => {
+  const { numberOfCar } = useIntlayer("car_count");
+
+  return (
+    <div>
+      <p>
+        {
+          numberOfCar(0) // Saída: Nenhum carro
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(6) // Saída: Alguns carros
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(20) // Saída: Muitos carros
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(0.01) // Saída: Valor padrão
+        }
+      </p>
+    </div>
+  );
+};
+
+export default CarComponent;
+```
+
+```javascript fileName="**/*.cjs" codeFormat="commonjs"
+const { useIntlayer } = require("react-intlayer");
+
+const CarComponent = () => {
+  const { numberOfCar } = useIntlayer("car_count");
+
+  return (
+    <div>
+      <p>
+        {
+          numberOfCar(0) // Saída: Nenhum carro
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(6) // Saída: Alguns carros
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(20) // Saída: Muitos carros
+        }
+      </p>
+      <p>
+        {
+          numberOfCar(0.01) // Saída: Valor padrão
+        }
+      </p>
+    </div>
+  );
+};
+
+module.exports = CarComponent;
+```
+
+Neste exemplo, o componente ajusta dinamicamente sua saída com base no número de carros. O conteúdo correto é escolhido automaticamente, dependendo do intervalo especificado.
+
+## Recursos Adicionais
+
+Para informações mais detalhadas sobre configuração e uso, consulte os seguintes recursos:
+
+- [Documentação do Intlayer CLI](https://github.com/aymericzip/intlayer/blob/main/docs/pt/intlayer_cli.md)
+- [Documentação do React Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/pt/intlayer_with_create_react_app.md)
+- [Documentação do Next Intlayer](https://github.com/aymericzip/intlayer/blob/main/docs/pt/intlayer_with_nextjs_15.md)
+
+Esses recursos fornecem mais informações sobre a configuração e uso do Intlayer em diferentes ambientes e com vários frameworks.