frodovdr/node-red
1
0
Fork 0
mirror of https://github.com/node-red/node-red.git synced 2023-10-10 13:36:53 +02:00
Code Issues Releases Wiki Activity

Merge pull request #3804 from FabsMuller/ptbrtranslation

Browse Source 
Portuguese Brazilian (pt-BR) translation
This commit is contained in:
Nick O'Leary 2023-03-03 13:33:47 +00:00 committed by GitHub
commit c046c8c4d3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
47 changed files with 4703 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
packages/node_modules/@node-red/editor-client/locales/de/editor.json vendored
View File

@ -1177,6 +1177,7 @@
"en-US": "Englisch", "en-US": "Englisch",
"ja": "Japanisch", "ja": "Japanisch",
"ko": "Koreanisch", "ko": "Koreanisch",
"pt-BR":"Portugiesisch",
"ru": "Russisch", "ru": "Russisch",
"zh-CN": "Chinesisch (Vereinfacht)", "zh-CN": "Chinesisch (Vereinfacht)",
"zh-TW": "Chinesisch (Traditionell)" "zh-TW": "Chinesisch (Traditionell)"

1
packages/node_modules/@node-red/editor-client/locales/en-US/editor.json vendored
View File

@ -1202,6 +1202,7 @@
"en-US": "English", "en-US": "English",
"ja": "Japanese", "ja": "Japanese",
"ko": "Korean", "ko": "Korean",
"pt-BR":"Portuguese",
"ru": "Russian", "ru": "Russian",
"zh-CN": "Chinese(Simplified)", "zh-CN": "Chinese(Simplified)",
"zh-TW": "Chinese(Traditional)" "zh-TW": "Chinese(Traditional)"

1
packages/node_modules/@node-red/editor-client/locales/ja/editor.json vendored
View File

@ -1202,6 +1202,7 @@
"en-US": "英語", "en-US": "英語",
"ja": "日本語", "ja": "日本語",
"ko": "韓国語", "ko": "韓国語",
"pt-BR":"ポルトガル語",
"ru": "ロシア語", "ru": "ロシア語",
"zh-CN": "中国語(簡体)", "zh-CN": "中国語(簡体)",
"zh-TW": "中国語(繁体)" "zh-TW": "中国語(繁体)"

1208
packages/node_modules/@node-red/editor-client/locales/pt-BR/editor.json vendored Normal file
View File

File diff suppressed because it is too large Load Diff

23
packages/node_modules/@node-red/editor-client/locales/pt-BR/infotips.json vendored Executable file
View File

@ -0,0 +1,23 @@
{
"info": {
"tip0": "Você pode remover os nós ou links selecionados com {{core:delete-selection}}",
"tip1": "Procure por nós usando {{core:search}}",
"tip2": "{{core:toggle-sidebar}} irá alternar a visualização desta barra lateral",
"tip3": "Você pode gerenciar sua paleta de nós com {{core:manage-palette}}",
"tip4": "Seus nós de configuração de fluxo são listados no painel da barra lateral. Pode ser acessado a partir do menu ou com{{core:show-config-tab}}",
"tip5": "Habilite ou desabilite essas dicas na opção nas configurações",
"tip6": "Mova os nós selecionados usando o [left] [up] [down] e [right] chaves. Segure [shift] para empurrá-los ainda mais",
"tip7": "Arrastar um nó para um fio o unirá no link",
"tip8": "Exporte os nós selecionados ou a guia atual com {{core:show-export-dialog}}",
"tip9": "Importe um fluxo arrastando seu JSON para o editor ou com {{core:show-import-dialog}}",
"tip10": "[shift] [click] e arraste em uma porta de nó para mover todos os fios conectados ou apenas o selecionado",
"tip11": "Mostre a guia Informações com {{core:show-info-tab}} ou a guia Depurar com {{core:show-debug-tab}}",
"tip12": "[ctrl] [click] na área de trabalho para abrir a caixa de diálogo de adição rápida",
"tip13": "Mantenha pressionado [ctrl] enquanto você [click] em uma porta de nó para habilitar a ligação rápida",
"tip14": "Mantenha pressionado [shift] enquanto você [click] em um nó para também selecionar todos os seus nós conectados",
"tip15": "Mantenha pressionado [ctrl] enquanto você [click] em um nó para adicioná-lo ou removê-lo da seleção atual",
"tip16": "Alternar guias de fluxo com {{core:show-previous-tab}} e {{core:show-next-tab}}",
"tip17": "Você pode confirmar suas alterações na bandeja de edição do nó com {{core:confirm-edit-tray}} ou cancele-os com {{core:cancel-edit-tray}}",
"tip18": "Pressionando {{core:edit-selected-node}} irá editar o primeiro nó na seleção atual"
}
}

274
packages/node_modules/@node-red/editor-client/locales/pt-BR/jsonata.json vendored Executable file
View File

@ -0,0 +1,274 @@
{
"$string": {
"args": "arg[, prettify]",
"desc": "Converte o tipo do parâmetro `arg` em uma cadeia de caracteres usando as seguintes regras de conversão de tipo:\n\n - Cadeia de caracteres não são alteradas\n - As funções são convertidas para uma cadeia de caracteres vazia\n - os tipos numérico infinito e NaN geram um erro porque não podem ser representados como um número JSON\n - Todos os outros valores são convertidos para uma cadeia de caracteres JSON usando a função `JSON.stringify`. Se `prettify` for verdadeira, então o JSON \"prettified\" é produzido. Isto é, uma linha por campo e as linhas serão indentadas com base na profundidade do campo."
},
"$length": {
"args": "str",
"desc": "Retorna o número de caracteres na cadeia de caracteres `str`. Um erro é gerado se `str` não for uma cadeia de caracteres."
},
"$substring": {
"args": "str, start[, length]",
"desc": "Retorna uma cadeia de caracteres contendo os caracteres no primeiro parâmetro `str` começando na posição `start` (deslocamento zero). Se` length` for especificado, então a sub cadeia de caracteres conterá o máximo `length` de caracteres. Se` start` for negativo isso indica o número de caracteres a partir do fim de `str`."
},
"$substringBefore": {
"args": "str, chars",
"desc": "Retorna a sub cadeia de caracteres antes da primeira ocorrência da sequência de caracteres `chars` em `string`. Se` string` não contiver `chars`, então retorna `str`. "
},
"$substringAfter": {
"args": "str, chars",
"desc": "Retorna a sub cadeia de caracteres após a primeira ocorrência da sequência de caracteres `chars` em `string`. Se `string` não contiver `chars`, então retorna `str`. "
},
"$uppercase": {
"args": "str",
"desc": "Retorna uma cadeia de caracteres com todos os caracteres de `string` convertidos em maiúsculas. "
},
"$lowercase": {
"args": "str",
"desc": "Retorna uma cadeia de caracteres com todos os caracteres de `string` convertidos em minúsculas. "
},
"$trim": {
"args": "str",
"desc": "Normaliza e retira todos os caracteres de espaço em branco em `str` aplicando as seguintes etapas:\n\n - Todas as tabulações, retornos de carro e avanços de linha são substituídos por espaços.\n- Sequências contíguas de espaços são reduzidas a um único espaço.\n- Espaços à direita e à esquerda são removidos.\n\n Se `str` não for especificado (isto é, esta função é chamada sem argumentos), então o valor do contexto é usado como o valor de `str`. Um erro é gerado se `str` não for uma cadeia de caracteres."
},
"$contains": {
"args": "str, pattern",
"desc": "Retorna `true` se `str` tiver correspondente em `pattern`, caso contrário, retorna `false`. Se `str` não for especificado (isto é, esta função é chamada com um argumento), então o valor do contexto é usado como o valor de `str`. O parâmetro `pattern` pode ser uma cadeia de caracteres ou uma expressão regular. "
},
"$split": {
"args": "str[, separator][, limit]",
"desc": "Divide o parâmetro `str` em uma matriz de sub cadeia de caracteres. É um erro se `str` não for uma cadeia de caracteres. O parâmetro opcional `separator` especifica os caracteres dentro de `str` sobre os quais devem ser divididos como uma cadeia de caracteres ou expressão regular. Se `separator` não for especificado, a cadeia de caracteres vazia será assumida e `str` será dividido em uma matriz de caracteres únicos. É um erro se `separador` não for uma cadeia de caracteres. O parâmetro opcional `limit` é um número que especifica o número máximo de sub cadeia de caracteres a serem incluídas na matriz resultante. Quaisquer sub cadeia de caracteres adicionais são descartadas. Se `limit` não for especificado, então `str` será totalmente dividido sem limite para o tamanho da matriz resultante . É um erro se `limit` não for um número não negativo."
},
"$join": {
"args": "array[, separator]",
"desc": "Une uma matriz de cadeias de caracteres de componentes em uma única cadeia de caracteres concatenada com cada cadeia de caracteres de componente separada pelo parâmetro opcional `separator`. É um erro se a `matriz` de entrada contiver um item que não seja uma cadeia de caracteres. Se `separator` for não especificado, assume-se que é uma cadeia de caracteres vazia, ou seja, nenhum `separator` entre as cadeias de caracteres do componente. É um erro se `separator` não for uma cadeia de caracteres. "
},
"$match": {
"args": "str, pattern [, limit]",
"desc": "Aplica a cadeia de caracteres `str` à expressão regular `pattern` e retorna uma matriz de objetos, com cada objeto contendo informações sobre cada ocorrência de uma correspondência dentro de `str`. "
},
"$replace": {
"args": "str, pattern, replacement [, limit]",
"desc": "Encontra ocorrências de `pattern` dentro de `str` e as substitui por `replacement`.\n\nO parâmetro opcional `limit` é o número máximo de substituições."
},
"$now": {
"args":"$[picture [, timezone]]",
"desc":"Gera um carimbo de data/hora em formato compatível com ISO 8601 e o retorna como uma cadeia de caracteres. Se os parâmetros opcionais de imagem e fuso horário forem fornecidos, o carimbo de data/hora atual é formatado conforme descrito pela função `$ fromMillis ()`"
},
"$base64encode": {
"args":"string",
"desc":"Converte uma cadeia de caracteres ASCII em uma representação de base 64. Cada caractere na cadeia de caracteres é tratado como um byte de dados binários. Isso requer que todos os caracteres na cadeia de caracteres estejam no intervalo de 0x00 a 0xFF, o que inclui todos os caracteres em cadeias de caracteres codificadas em URI. Caracteres Unicode fora desse intervalo não são suportados."
},
"$base64decode": {
"args":"string",
"desc":"Converte bytes codificados de base 64 em uma cadeia de caracteres, usando uma página de código UTF-8 Unicode."
},
"$number": {
"args": "arg",
"desc": "Converte o parâmetro `arg` em um número usando as seguintes regras de conversão:\n\n - Os números permanecem inalterados\n - Cadeias de caracteres que contêm uma sequência de caracteres que representam um número JSON válido são convertidos para esse número\n - Todos os outros valores causam a geração de um erro."
},
"$abs": {
"args":"number",
"desc":"Retorna o valor absoluto do parâmetro `number`."
},
"$floor": {
"args":"number",
"desc":"Retorna o valor de `number` arredondado para baixo para o inteiro mais próximo que seja menor ou igual a `number`."
},
"$ceil": {
"args":"number",
"desc":"Retorna o valor de `number` arredondado para o número inteiro mais próximo que é maior ou igual a `number`."
},
"$round": {
"args":"number [, precision]",
"desc":"Retorna o valor do parâmetro `number` arredondado para o número de casas decimais especificado pelo parâmetro opcional `precision`."
},
"$power": {
"args":"base, exponent",
"desc":"Retorna o valor de `base` elevado à potência de `exponent`."
},
"$sqrt": {
"args":"number",
"desc":"Retorna a raiz quadrada do valor do parâmetro `number`."
},
"$random": {
"args":"",
"desc":"Retorna um número pseudoaleatório maior ou igual a zero e menor que um."
},
"$millis": {
"args":"",
"desc":"Retorna o número de milissegundos desde o Unix Epoch (1º de janeiro de 1970 UTC) como um número. Todas as invocações de `$ millis ()` dentro de uma avaliação de uma expressão retornarão todas o mesmo valor."
},
"$sum": {
"args": "array",
"desc": "Retorna a soma aritmética de uma `array` de números. É um erro se o `array` de entrada contiver um item que não seja um número."
},
"$max": {
"args": "array",
"desc": "Retorna o número máximo em uma `array` de números. É um erro se o `array` de entrada contiver um item que não seja um número."
},
"$min": {
"args": "array",
"desc": "Retorna o número mínimo em uma `array` de números. É um erro se o `array` de entrada contiver um item que não seja um número."
},
"$average": {
"args": "array",
"desc": "Retorna o valor médio de uma `array` de números. É um erro se o `array` de entrada contiver um item que não seja um número."
},
"$boolean": {
"args": "arg",
"desc": "Converte o argumento em um booliano usando as seguintes regras:\n\n - `Boolean` : inalterado\n - `string`: vazio : `false`\n - `string`: não-vazio : `true`\n - `number`: `0` : `false`\n - `number`: não-zero : `true`\n - `null` : `false`\n - `array`: vazio : `false`\n - `array`: contém um membro que converte de tipo para `true` : `true`\n - `array`: todos os membros convertidos de tipo para `false` : `false`\n - `object`: vazio : `false`\n - `object`: não-vazio : `true`\n - `function` : `false`"
},
"$not": {
"args": "arg",
"desc": "Retorna booliano NOT no argumento. `Arg` é convertido de tipo primeiro para um booliano "
},
"$exists": {
"args": "arg",
"desc": "Retorna booliano `true` se a expressão `arg` for avaliada como um valor, ou `false` se a expressão não corresponder a nada (por exemplo, um caminho para uma referência de campo inexistente)."
},
"$count": {
"args": "array",
"desc": "Retorna o número de itens na matriz"
},
"$append": {
"args": "array, array",
"desc": "Anexa duas matrizes"
},
"$sort": {
"args":"array [, function]",
"desc":"Retorna uma matriz contendo todos os valores no parâmetro `array`, mas classificados em ordem.\n\nSe um comparador `function` for fornecido, então deve ser uma função que leva dois parâmetros:\n\n`function(left, right)`\n\nEsta função é invocada pelo algoritmo de classificação para comparar dois valores à esquerda e à direita. Se o valor de esquerda deve ser colocado após o valor de direita na ordem de classificação desejada, a função deve retornar o booliano `true` para indicar uma troca. Caso contrário, deve retornar `false`."
},
"$reverse": {
"args":"array",
"desc":"Retorna uma matriz contendo todos os valores do parâmetro `array`, mas na ordem reversa. "
},
"$shuffle": {
"args":"array",
"desc":"Retorna uma matriz contendo todos os valores do parâmetro `array`, mas misturados em ordem aleatória. "
},
"$zip": {
"args":"array, ...",
"desc":"Retorna uma matriz convolucional (compactada) contendo matrizes agrupadas de valores dos argumentos `array1`… `arrayN` do índice 0, 1, 2 ...."
},
"$keys": {
"args": "object",
"desc": "Retorna uma matriz contendo as chaves do objeto. Se o argumento for uma matriz de objetos, então a matriz retornada contém uma lista não duplicada de todas as chaves em todos os objetos."
},
"$lookup": {
"args": "object, key",
"desc": "Retorna o valor associado à chave no objeto. Se o primeiro argumento for uma matriz de objetos, todos os objetos na matriz são pesquisados e os valores associados a todas as ocorrências da chave são retornados."
},
"$spread": {
"args": "object",
"desc": "Divide um objeto que contém pares de chave/valor em uma matriz de objetos, cada um com um único par de chave/valor do objeto de entrada. Se o parâmetro for uma matriz de objetos, a matriz resultante conterá um objeto para cada par de chave/valor em todo objeto na matriz fornecida. "
},
"$merge": {
"args": "array<object>",
"desc": "Mescla uma matriz de `objects` em um único `object` contendo todos os pares de chave/valor de cada um dos objetos na matriz de entrada. Se qualquer um dos objetos de entrada contiver a mesma chave, então o `object` retornado conterá o valor do último na matriz. É um erro se a matriz de entrada contiver um item que não seja um objeto."
},
"$sift": {
"args":"object, function",
"desc": "Retorna um objeto que contém apenas os pares de chave/valor do parâmetro `object` que satisfazem o predicado `function` passado como o segundo parâmetro.\n\nA `function` que é fornecida como o segundo parâmetro deve ter o seguinte assinatura:\n\n`function(value [, key [, object]])`"
},
"$each": {
"args":"object, function",
"desc":"Retorna uma matriz contendo os valores retornados por `function` quando aplicado a cada par chave/valor no `object`."
},
"$map": {
"args":"array, function",
"desc":"Retorna uma matriz contendo os resultados da aplicação do parâmetro `function` a cada valor no parâmetro `array`.\n\nA `function` que é fornecido como o segundo parâmetro deve ter a seguinte assinatura:\n\n`function(value [, index [, array]])`"
},
"$filter": {
"args":"array, function",
"desc":"Retorna uma matriz contendo apenas os valores no parâmetro `array` que satisfazem o predicado `function`.\n\nThe `function` que é fornecido como o segundo parâmetro deve ter a seguinte assinatura:\n\n`function(value [, index [, array]])`"
},
"$reduce": {
"args":"array, function [, init]",
"desc":"Retorna um valor agregado derivado da aplicação do parâmetro `function` sucessivamente a cada valor em `array` em combinação com o resultado da aplicação anterior da função.\n\nA função deve aceitar dois argumentos e se comportar como um operador inserido entre cada valor dentro de `array`. A assinatura da `function` deve estar no formato: `myfunc($accumulator, $value[, $index[, $array]])`\n\nO parâmetro opcional `init` é usado como o valor inicial na agregação."
},
"$flowContext": {
"args": "string[, string]",
"desc": "Recupera uma propriedade de contexto de fluxo.\n\nEsta é uma função definida pelo Node-RED. "
},
"$globalContext": {
"args": "string[, string]",
"desc": "Recupera uma propriedade de contexto global.\n\nEsta é uma função definida pelo Node-RED. "
},
"$pad": {
"args": "string, width [, char]",
"desc": "Retorna uma cópia da `string` com preenchimento extra, se necessário, de forma que seu número total de caracteres seja pelo menos o valor absoluto do parâmetro `width`.\n\nSe `width` for um número positivo, a cadeia de caracteres será preenchida à direita; se negativo, é preenchida à esquerda.\n\nO argumento opcional `char` especifica os caracteres de preenchimento a serem usados. Se não for especificado, o padrão é o caractere de espaço. "
},
"$fromMillis": {
"args": "number, [, picture [, timezone]]",
"desc": "Converta o `number` que representa os milissegundos desde a época do Unix (1 January, 1970 UTC) em uma representação de cadeia de caracteres formatada do carimbo de data/hora conforme especificado pela cadeia de caracteres de imagem.\n\nSe o parâmetro opcional `image` for omitido, o carimbo de data/hora será formatado no formato ISO 8601.\n\nSe a cadeia de caracteresopcional `picture` for fornecida, o carimbo de data/hora é formatado de acordo com a representação especificada nessa cadeia de caracteres. O comportamento desta função é consistente com a versão de dois argumentos da função XPath/XQuery `format-dateTime` conforme definido na especificação XPath F&O 3.1. O parâmetro de cadeia de caracteres de imagem define como o carimbo de data/hora é formatado e tem a mesma sintaxe de `format-dateTime`.\n\nSe a cadeia de caracteres opcional `timezone` for fornecida, o carimbo de data/hora formatado estará nesse fuso horário. A cadeia de caracteres `timezone` deve estar no formato '± HHMM', onde ± é o sinal de mais ou menos e HHMM é o deslocamento em horas e minutos do UTC. Deslocamento positivo para fusos horários a leste do UTC, deslocamento negativo para fusos horários a oeste do UTC. "
},
"$formatNumber": {
"args": "number, picture [, options]",
"desc": "Converte o tipo de `number` em uma cadeia de caracteres e o formata em uma representação decimal conforme especificado pela cadeia de caracteres `picture`.\n\n O comportamento desta função é consistente com a função XPath/XQuery fn: format-number conforme definido na especificação XPath F&O 3.1. O parâmetro de cadeia de caracteres de imagem define como o número é formatado e tem a mesma sintaxe de fn: format-number.\n\nO terceiro argumento opcional `options` é usado para substituir os caracteres de formatação específicos da localidade padrão, como o separador decimal. Se fornecido, este argumento deve ser um objeto contendo pares de nome/valor especificados na seção de formato decimal da especificação XPath F&O 3.1."
},
"$formatBase": {
"args": "number [, radix]",
"desc": "Converte o `number` em uma cadeia de caracteres e o formata em um inteiro representado na base do número especificada pelo argumento `radix`. Se `radix` não for especificado, o padrão é a base 10. `radix` pode estar entre 2 e 36, caso contrário, um erro será gerado. "
},
"$toMillis": {
"args": "timestamp",
"desc": "Converta o tipo de uma cadeia de caracteres `timestamp` no formato ISO 8601 para o número de milissegundos desde a época do Unix (1 January, 1970 UTC) como um número. Um erro é gerado se a cadeia de caracteres não estiver no formato correto. "
},
"$env": {
"args": "arg",
"desc": "Retorna o valor de uma variável de ambiente.\n\nEsta é uma função definida pelo Node-RED."
},
"$eval": {
"args": "expr [, context]",
"desc": "Analisa e avalia a cadeia de caracteres `expr` que contém um JSON literal ou uma expressão JSONata usando o contexto atual como o contexto para avaliação. "
},
"$formatInteger": {
"args": "number, picture",
"desc": "Converte o tipo de `number` em uma cadeia de caracteres e o formata em uma representação inteira conforme especificado pela cadeia de caracteres `picture`. O parâmetro da cadeia de caracteres de imagem define como o número é formatado e tem a mesma sintaxe de `fn: format-integer` do Especificação XPath F&O 3.1. "
},
"$parseInteger": {
"args": "string, picture",
"desc": "Examina e troca o conteúdo do parâmetro `string` para um inteiro (como um número JSON) usando o formato especificado pela cadeia de caracteres `picture`. O parâmetro da cadeia de caracteres `picture` tem o mesmo formato que `$ formatInteger`."
},
"$error": {
"args": "[str]",
"desc": "Gera um erro com uma mensagem. O (parâmetro) opcional `str` substituirá a mensagem padrão de `$error() function evaluated`"
},
"$assert": {
"args": "arg, str",
"desc": "Se `arg` for verdadeiro, a função retorna indefinido. Se `arg` for falso, uma exceção é gerada com `str` como a mensagem da exceção. "
},
"$single": {
"args": "array, function",
"desc": "Retorna o único valor no parâmetro `array` que satisfaz o predicado `function` (isto é, O (parâmetro) `function` retorna o booliano `true` quando passado o valor). Gera uma exceção se o número de valores correspondentes não for exatamente um .\n\nA função deve ser fornecida na seguinte assinatura: `function(value [, index [, array]])` onde 'value' é cada entrada da matriz, 'index' é a posição desse valor e toda a matriz é passada como o terceiro argumento"
},
"$encodeUrlComponent": {
"args": "str",
"desc": "Codifica um componente Localizador Uniforme de Recursos (URL) substituindo cada instância de certos caracteres por uma, duas, três ou quatro sequências de escape que representam a codificação UTF-8 do caractere.\n\nExemplo: `$encodeUrlComponent(\"?x=test\")` => `\"%3Fx%3Dtest\"`"
},
"$encodeUrl": {
"args": "str",
"desc": "Codifica um Localizador Uniforme de Recursos (URL) substituindo cada instância de certos caracteres por uma, duas, três ou quatro sequências de escape que representam a codificação UTF-8 do caractere. \n\nExemplo: `$encodeUrl(\"https://mozilla.org/?x=шеллы\")` => `\"https://mozilla.org/?x=%D1%88%D0%B5%D0%BB%D0%BB%D1%8B\"`"
},
"$decodeUrlComponent": {
"args": "str",
"desc": "Decodifica um componente Localizador Uniforme de Recursos (URL) criado anteriormente por encodeUrlComponent. \n\nExemplo: `$decodeUrlComponent(\"%3Fx%3Dtest\")` => `\"?x=test\"`"
},
"$decodeUrl": {
"args": "str",
"desc": "Decodifica um Localizador Uniforme de Recursos (URL) criado anteriormente por encodeUrl. \n\nExemplo: `$decodeUrl(\"https://mozilla.org/?x=%D1%88%D0%B5%D0%BB%D0%BB%D1%8B\")` => `\"https://mozilla.org/?x=шеллы\"`"
},
"$distinct": {
"args": "array",
"desc": "Retorna uma matriz com valores duplicados removidos da `array` "
},
"$type": {
"args": "value",
"desc": "Retorna o tipo de `value` como uma cadeia de caracteres. Se `value` for indefinido, retornará `undefined` "
},
"$moment": {
"args": "[str]",
"desc": "Obtém um objeto de dados usando a biblioteca 'Moment'."
}
}

1
packages/node_modules/@node-red/editor-client/locales/ru/editor.json vendored
View File

@ -1135,6 +1135,7 @@
"en-US": "Английский", "en-US": "Английский",
"ja": "Японский", "ja": "Японский",
"ko": "Корейский", "ko": "Корейский",
"pt-BR":"португальский",
"ru": "Русский", "ru": "Русский",
"zh-CN": "Китайский (упрощенный)", "zh-CN": "Китайский (упрощенный)",
"zh-TW": "Китайский (традиционный)" "zh-TW": "Китайский (традиционный)"

2
packages/node_modules/@node-red/editor-client/locales/zh-CN/editor.json vendored
View File

@ -1089,6 +1089,8 @@
"en-US": "英文", "en-US": "英文",
"ja": "日语", "ja": "日语",
"ko": "韩文", "ko": "韩文",
"pt-BR":"葡萄牙语",
"ru":"俄語",
"zh-CN": "简体中文", "zh-CN": "简体中文",
"zh-TW": "繁体中文" "zh-TW": "繁体中文"
} }

2
packages/node_modules/@node-red/editor-client/locales/zh-TW/editor.json vendored
View File

@ -1090,6 +1090,8 @@
"en-US": "英語", "en-US": "英語",
"ja": "日語", "ja": "日語",
"ko": "韓語", "ko": "韓語",
"pt-BR":"葡萄牙语",
"ru":"俄語",
"zh-CN": "簡體中文", "zh-CN": "簡體中文",
"zh-TW": "繁體中文" "zh-TW": "繁體中文"
} }

2
packages/node_modules/@node-red/nodes/locales/en-US/network/21-httprequest.html vendored
View File

@ -73,7 +73,7 @@
<h4>Cookie handling</h4> <h4>Cookie handling</h4>
<p>The <code>cookies</code> property passed to the node must be an object of name/value pairs. <p>The <code>cookies</code> property passed to the node must be an object of name/value pairs.
The value can be either a string to set the value of the cookie or it can be an The value can be either a string to set the value of the cookie or it can be an
object with a single <code>value</code> property.<p> object with a single <code>value</code> property.</p>
<p>Any cookies returned by the request are passed back under the <code>responseCookies</code> property.</p> <p>Any cookies returned by the request are passed back under the <code>responseCookies</code> property.</p>
<h4>Content type handling</h4> <h4>Content type handling</h4>
<p>If <code>msg.payload</code> is an Object, the node will automatically set the content type <p>If <code>msg.payload</code> is an Object, the node will automatically set the content type

40
packages/node_modules/@node-red/nodes/locales/pt-BR/common/20-inject.html vendored Normal file
View File

@ -0,0 +1,40 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="inject">
<p>Injeta uma mensagem em um fluxo manualmente ou em intervalos regulares. A carga útil da mensagem
pode ser de vários tipos, incluindo cadeia de caracteres, objetos JavaScript ou a hora atual.</p>
<h3>Saídas</h3>
<dl class="message-properties">
<dt>carga útil<span class="property-type">vários</span></dt>
<dd>A carga útil configurada da mensagem.</dd>
<dt class="optional">tópico <span class="property-type">cadeia de caracteres</span></dt>
<dd>Uma propriedade opcional que pode ser configurada no nó.</dd>
</dl>
<h3>Detalhes</h3>
<p>O nó Inject pode iniciar um fluxo com um valor de carga útil específico.
A carga útil padrão é um carimbo de data/hora da hora atual em milissegundos desde 1º de janeiro de 1970.</p>
<p>O nó também oferece suporte à injeção de cadeia de caracteres, números, boolianos, objetos JavaScript ou valores de contexto de fluxo/global.</p>
<p>Por padrão, o nó é acionado manualmente clicando em seu botão no editor. Também pode ser configurado para
injetar em intervalos regulares ou de acordo com um cronograma.</p>
<p>também pode ser configurado para injetar uma unica vez cada vez que os fluxos forem iniciados.</p>
<p>O <i>Intervalo</i> máximo que pode ser especificado é de cerca de 596 horas / 24 dias. No entanto, se forem observados intervalos
maiores do que um dia, você deve considerar o uso de um nó organizador que possa lidar com quedas de energia e reinicializações.</p>
<p><b>Nota</b>: As opções<i>"Intervalo entre os tempos"</i> e <i>"em um horário específico"</i> usam o sistema cron padrão.
Isso significa que 20 minutos estarão na próxima hora, 20 minutos atrás e 40 minutos atrás - não em tempos de 20 minutos.
Se você quiser cada 20 minutos a partir de agora - use a opção <i> "intervalo"</i>.</p>
<p><b>Nota</b>: para incluir uma nova linha em uma cadeia de caracteres, você deve usar um nó de Função para criar a carga útil.</p>
</script>

26
packages/node_modules/@node-red/nodes/locales/pt-BR/common/21-debug.html vendored Normal file
View File

@ -0,0 +1,26 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="debug">
<p>Exibe as propriedades da mensagem selecionada na guia de depuração da barra lateral e, opcionalmente, o log do tempo de execução. Por padrão, ele exibe <code> msg.payload </code>, mas pode ser configurado para exibir qualquer propriedade, a mensagem completa ou o resultado de uma expressão JSONata.</p>
<h3>Detalhes</h3>
<p>A barra lateral de depuração fornece uma visão estruturada das mensagens enviadas, facilitando o entendimento de sua estrutura.</p>
<p>Objetos e matrizes JavaScript podem ser recolhidos e expandidos conforme necessário. Objetos de aramazenamento temporário podem ser exibidos como dados brutos ou como uma cadeia de caracteres, se possível.</p>
<p>Juntamente com cada mensagem, a barra lateral de depuração inclui informações sobre a hora em que a mensagem foi recebida, o nó que a enviou e o tipo da mensagem.
Clicar no id do nó de origem revelará esse nó no espaço de trabalho.</p>
<p>O botão no nó pode ser usado para habilitar ou desabilitar sua saída. É recomendado desativar ou remover quaisquer nós de depuração que não estejam sendo usados.</p>
<p>O nó também pode ser configurado para enviar todas as mensagens para o log de tempo de execução ou para enviar mensagens curtas (32 caracteres) para o texto de estado sob o nó de depuração.</p>
</script>

29
packages/node_modules/@node-red/nodes/locales/pt-BR/common/24-complete.html vendored Normal file
View File

@ -0,0 +1,29 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="complete">
<p>Aciona um fluxo quando outro nó concluir o tratamento de uma mensagem.</p>
<h3>Detalhes</h3>
<p>Se um nó informar o tempo de execução quando terminar de lidar com uma mensagem,
este nó pode ser usado para acionar um segundo fluxo.</p>
<p>Por exemplo, isso pode ser usado junto com um nó sem porta de saída,
como o nó de envio de e-mail, para continuar o fluxo.</p>
<p>Este nó deve ser configurado para lidar com o evento para nós selecionados no
fluxo. Ao contrário do nó de captura, ele não fornece um modo 'manipular todos' automaticamente
que se aplica a todos os nós no fluxo.</p>
<p>Nem todos os nós irão acionar este evento - vai depender se eles
foram implementados para oferecer suporte a esse recurso, conforme introduzido no Node-RED 1.0.</p>
</script>

42
packages/node_modules/@node-red/nodes/locales/pt-BR/common/25-catch.html vendored Normal file
View File

@ -0,0 +1,42 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="catch">
<p>Capture erros lançados por nós na mesma guia.</p>
<h3>Saídas</h3>
<dl class = "message-properties">
<dt>error.message <span class="property-type">cadeia de caracteres</span></dt>
<dd>a mensagem de erro.</dd>
<dt>error.source.id <span class="property-type">cadeia de caracteres</span></dt>
<dd>o id do nó que gerou o erro.</dd>
<dt>error.source.type <span class="property-type">cadeia de caracteres</span></dt>
<dd>o tipo de nó que gerou o erro.</dd>
<dt>error.source.name <span class="property-type">cadeia de caracteres</span></dt>
<dd>o nome, se definido, do nó que gerou o erro.</dd>
</dl>
<h3>Detalhes</h3>
<p>Se um nó lançar um erro ao lidar com uma mensagem, o fluxo normalmente
para. Este nó pode ser usado para capturar esses erros e tratá-los com um
fluxo dedicado.</p>
<p>Por padrão, o nó irá capturar erros gerados por qualquer nó na mesma guia. Alternativamente
pode ser direcionado a nós específicos ou configurado para detectar apenas erros que
ainda não foram capturados por um nó de captura 'direcionado'.</p>
<p>Quando um erro é gerado, todos os nós de captura correspondentes receberão a mensagem.</p>
<p>Se um erro for gerado em um subfluxo, o erro será tratado por quaisquer
nós de captura dentro do subfluxo. Se nenhum existir, o erro será propagado
até a guia, a instância do subfluxo está ativada.</p>
<p>Se a mensagem já tiver uma propriedade <code>error</code>, ela será copiada para <code>_error</code>.</p>
</script>

34
packages/node_modules/@node-red/nodes/locales/pt-BR/common/25-status.html vendored Normal file
View File

@ -0,0 +1,34 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="status">
<p>Reportar mensagens de estado de outros nós na mesma guia.</p>
<h3>Saídas</h3>
<dl class="message-properties">
<dt>status.text <span class="property-type">string</span></dt>
<dd>o texto do estado.</dd>
<dt>status.source.type <span class="property-type">string</span></dt>
<dd>o tipo de nó que relatou o estado.</dd>
<dt>status.source.id <span class="property-type">string</span></dt>
<dd>o id do nó que relatou o estado.</dd>
<dt>status.source.name <span class="property-type">string</span></dt>
<dd>o nome, se definido, do nó que relatou o estado.</dd>
</dl>
<h3>Detalhes</h3>
<p>Este nó não produz uma <code>carga útil</code>.</p>
<p>Por padrão, o nó relata o estado de todos os nós na mesma guia da área de trabalho.
Pode ser configurado para relatar seletivamente o estado de nós individuais.</p>
</script>

66
packages/node_modules/@node-red/nodes/locales/pt-BR/common/60-link.html vendored Normal file
View File

@ -0,0 +1,66 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="link in">
<p>Crie fios virtuais entre fluxos. </p>
<h3>Detalhes</h3>
<p>O nó pode ser conectado a qualquer nó de <code>ligação de saída</code> que exista em qualquer guia.
Uma vez conectados, eles agem como se tivessem sido ligados em conjunto.</p>
<p>Os fios entre os nós de ligação são exibidos apenas quando um nó de ligação é selecionado.
Se existir quaisquer outros fios para outras guias; um nó virtual é exibido, onde pode-se clicar
e ser direcionado para a guia apropriada.</p>
<p><b>Observação:</b> as ligações não podem ser criadas entrando ou saindo de um subfluxo.</p>
</script>
<script type="text/html" data-help-name="link out">
<p>Crie conexões virtuais entre fluxos.</p>
<h3>Detalhes</h3>
<p>Este nó pode ser configurado para enviar mensagens para todos os nós de <code>ligação de entradas</code>
aos quais está conectado ou para enviar uma resposta de volta para o nó de <code>ligação de chamada</code>
que acionou o fluxo.</p>
<p>No modo 'enviar para todos', os fios entre os nós da ligação são exibidos apenas quando
o nó é selecionado. Se houver ligações para outras guias, um nó virtual
é mostrado; podendo ser clicado para se deslocar até a guia apropriada.</p>
<p><b>Observação:</b>As ligações não podem ser criadas em direação ao, ou saindo de, um subfluxo.</p>
</script>
<script type="text/html" data-help-name="link call">
<p>Chama um fluxo que começa com um nó de <code>ligação de entrada</code> e passa adiante a resposta.</p>
<h3>Entradas</h3>
<dl class="message-properties">
<dt class="opcional">destino<span class="property-type">cadeia de caracteres</span></dt>
<dd>Quando a opção <b>Tipo de ligação</b> estiver definida como "Destino dinâmico", defina <code>msg.target</code> como o nome do
nó de <code>ligação de entrada</code> que você deseja chamar.</dd>
</dl>
<h3>Detalhes</h3>
<p>Este nó pode ser conectado a um nó de <code>ligação de entrada</code> que exista em qualquer guia.
O fluxo conectado a esse nó deve terminar com um nó de <code>ligação de saída</code> configurado
no modo 'retorno'.</p>
<p>Quando este nó recebe uma mensagem, ela é passada para o nó de <code>ligação de entrada</code> conectado.
Em seguida, aguarda uma resposta que este então envia.</p>
<p>Se nenhuma resposta for recebida dentro do tempo limite configurado, padrão de 30 segundos, o nó
registrará um erro que pode ser detectado usando o nó de <code>captura</code>.</p>
<p>Quando a opção <b>Tipo de ligação</b> é definida como "Destino dinâmico", <code>msg.target</code> pode ser usado para chamar uma
<code>ligação de entrada</code> por nome ou id.
<ul>
<li>Se houver um nó de <code>ligação de entrada</code> com o mesmo id, este será chamado</li>
<li>Se houverem dois ou mais nós de <code>ligação de entrada</code> com o mesmo nome, um erro será gerado</li>
<li>Uma <code>chamada de ligação</code>não pode chamar um nó de <code>ligação de entrada</code> dentro de um subfluxo</li>
</ul>
</p>
O fluxo conectado a esse nó deve terminar com um nó de <code>ligação de saída</code> configurado
no modo 'retorno'.</p>
</script>

22
packages/node_modules/@node-red/nodes/locales/pt-BR/common/90-comment.html vendored Normal file
View File

@ -0,0 +1,22 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="comment">
<p>Um nó que você pode usar para adicionar comentários aos seus fluxos.</p>
<h3>Detalhes</h3>
<p>O painel de edição aceitará a sintaxe Markdown. O texto será renderizado neste
painel lateral de informações.</p>
</script>

28
packages/node_modules/@node-red/nodes/locales/pt-BR/common/98-unknown.html vendored Normal file
View File

@ -0,0 +1,28 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="unknown">
<p>Este nó é de um tipo desconhecido para a sua instalação do Node-RED.</p>
<h3>Detalhes</h3>
<p><i>Se você decidir implementar com o nó neste estado, sua configuração será preservada, mas
o fluxo não será iniciado até que o tipo ausente seja instalado.</i></p>
<p>Use a opção <code>Menu - Gerenciar paleta</code>
para pesquisar e instalar nós, ou <b>npm install &lt;module&gt;</b> para
instalar todos os módulos ausentes, reiniciar o Node-RED e reimportar os nós.</p>
<p>É possível que este tipo de nó já esteja instalado, mas que esteja faltando alguma dependência para sua correta execução. Verifique o log de inicialização do Node-RED
para quaisquer mensagens de erro associadas ao tipo de nó ausente.</p>
<p>Caso contrário, você deve entrar em contato com o autor do fluxo para obter uma cópia do tipo de nó ausente.</p>
</script>

64
packages/node_modules/@node-red/nodes/locales/pt-BR/function/10-function.html vendored Normal file
View File

@ -0,0 +1,64 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="function">
<p> Uma função JavaScript para abordar as mensagens recebidas pelo nó. </p>
<p> As mensagens são passadas como um objeto JavaScript chamado <code>msg</code>.</p>
<p> Por convenção, estas irão possuir uma propriedade <code>msg.payload</code> contendo
o corpo da mensagem.</p>
<p>Espera-se que a função retorne um objeto do tipo mensagem (ou vários objetos do tipo mensagem), mas a função pode escolher
não retornar nada visando interromper um fluxo.</p>
<p>A guia <b>On Start</b> contém um código que será executado sempre que o nó for iniciado.
A guia <b>On Stop</b> contém um código que será executado quando o nó for parado.</p>
<p>Se o código <b>On Start</b> retornar um objeto do tipo promessa, o nó não começará a tratar as mensagens
até que a promessa seja resolvida.</p>
<h3>Detalhes</h3>
<p>Consulte a <a target="_blank" href="http://nodered.org/docs/writing-functions.html">documentação online</a>
para obter maiores informações sobre funções de escrita.</p>
<h4>Enviando mensagens</h4>
<p>A função pode retornar as mensagens que deseja passar para os próximos nós
no fluxo ou pode chamar <code>node.send(messages)</code>.</p>
<p>A função pode retornar/enviar:</p>
<ul>
<li>um único objeto do tipo mensagem - passado para os nós conectados à primeira saída</li>
<li>uma matriz de objetos do tipo mensagem - passada para nós conectados às saídas correspondentes</li>
</ul>
<p>Nota: O código de configuração é executado durante a inicialização dos nós. Portanto, se <code>node.send</code> for chamado na guia de configuração, os nós subsequentes podem não serem capazes de receber a mensagem. </p>
<p>Se qualquer elemento da matriz é ele próprio uma matriz do tipo mensagens, múltiplas
mensagens são enviadas para a saída correspondente.</p>
<p>Se nulo for retornado, por si só ou como um elemento da matriz, nnehuma
mensagem é passada adiante.</p>
<h4>Registro e tratamento de erros</h4>
<p>Para registrar qualquer informação ou relatar um erro, as seguintes funções estão disponíveis: </p>
<ul>
<li> <code>node.log("Log message")</code> </li>
<li><code>node.warn("Warning"</code> </li>
<li><code>node.error("Error")</code> </li>
</ul>
</p>
<p> O nó de Captura também pode ser usado para lidar com erros. Para invocar um nó de Captura,
passe <code>msg</code> como um segundo argumento para <code>node.error</code>: </p>
<pre> node.error ("Erro", msg); </pre>
<h4>Acessando informações do nó</h4>
<p>As seguintes propriedades estão disponíveis para acessar informações sobre o nó:</p>
<ul>
<li> <code> node.id </code> - id do nó</li>
<li> <code> node.name </code> - nome do nó</li>
<li> <code> node.outputCount </code> - número de saídas de nós</li>
</ul>
<h4>Usando variáveis ​​de ambiente </h4>
<p> Variáveis ​​de ambiente podem ser acessadas usando <code>env.get("MY_ENV_VAR")</code>.</p>
</script>

50
packages/node_modules/@node-red/nodes/locales/pt-BR/function/10-switch.html vendored Normal file
View File

@ -0,0 +1,50 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="switch">
<p>Encaminhe mensagens com base em seus valores de propriedade ou posição de sequência.</p>
<h3>Detalhes</h3>
<p>Quando chega uma mensagem, o nó irá avaliar cada uma das regras definidas
e encaminhará a mensagem para as saídas correspondentes de quaisquer regras que combinem . </p>
<p>Opcionalmente, o nó pode ser configurado para parar de avaliar as regras assim que encontrar uma
que combine.</p>
<p> As regras podem ser avaliadas em relação a uma propriedade da mensagem individual, um fluxo (ou uma
propriedade de contexto global), variável de ambiente ou o resultado de uma expressão JSONata.</p>
<h4>Regras</h4>
<p>Existem quatro tipos de regras:</p>
<ol>
<li>Regras de <b>valor</b> são avaliadas em relação à propriedade configurada</li>
<li>Regras de <b>sequência</b> podem ser usadas em sequências de mensagens, como aquelas
gerado pelo nó Separador</li>
<li>Uma <b>Expressão</b> JSONata pode ser fornecida e avaliada,
em relação a toda mensagem; obtendo-se a correspondência se a expressão retornar
o valor booliano verdadeiro. </li>
<li>Uma regra <b>Caso contrário</b> pode ser usada para combinação se nenhuma das regras anteriores
encontrarem correspondentes.</li>
</ol>
<h4>Notas</h4>
<p> As regras <code>é verdadeiro/falso</code> e <code>é nulo</code> executam regras estritas
na comparaçao desses tipos e não fazem converção entre eles .</p>
<p> As regras <code>está vazio</code> e <code> não está vazio</code> podem ser usadas para testar o comprimento de: cadeia de caracteres, matrizes e armazenamentos temporários ou o número de propriedades que um Objeto possui. Nenhuma regra será aprovada se a propriedade que está sendo testada tiver um <code>booliano</code>, <code>mulo</code>
ou valor <code>indefinido</code>.</p>
<h4>Lidando com sequências de mensagens</h4>
<p>Por padrão, o nó não modifica a propriedade <code>msg.parts</code> das mensagens
que fazem parte de uma sequência.</p>
<p>A opção<b>recriar sequências de mensagens</b> pode ser habilitada para gerar novas sequências de mensagens
para cada regra que corresponda. Neste modo, o nó irá armazenar temporariamente toda a sequência de entrada
antes de enviar as novas sequências. A configuração de tempo de execução <code>nodeMessageBufferMaxLength</code>
pode ser usada para limitar o número de mensagens que os nós irão armazenar temporariamente.</p>
</script>

39
packages/node_modules/@node-red/nodes/locales/pt-BR/function/15-change.html vendored Normal file
View File

@ -0,0 +1,39 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="change">
<p>Definir, alterar, excluir ou mover propriedades de uma mensagem, contexto de fluxo ou contexto global.</p>
<p> O nó pode especificar várias regras que serão aplicadas na ordem em que estiverem definidas.</p>
<h3>Detalhes</h3>
<p>As operações disponíveis são:</p>
<dl class="message-properties">
<dt>Definir</dt>
<dd>define uma propriedade. O valor pode ser uma variedade de tipos diferentes ou
pode ser obtido de uma mensagem existente ou propriedade de contexto. </dd>
<dt>Mudar</dt>
<dd>pesquisa &amp; substitui partes da propriedade. Se as expressões regulares
estiverem ativadas, a propriedade "substituir por" pode incluir grupos de captura, para
exemplo <code>$1</code>. Substituir só mudará o tipo se houver
uma correspondência completa.</dd>
<dt>Excluir</dt>
<dd>excluí uma propriedade.</dd>
<dt>Mover</dt>
<dd>move ou renomeia uma propriedade.</dd>
</dl>
<p> O tipo "expressão" usa a linguagem de consulta e
expressão <a href="http://jsonata.org/" target="_new">JSONata</a>
</p>
</script>

44
packages/node_modules/@node-red/nodes/locales/pt-BR/function/16-range.html vendored Normal file
View File

@ -0,0 +1,44 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="range">
<p>Mapeia um valor numérico para um intervalo diferente.</p>
<h3>Entradas</h3>
<dl class="message-properties">
<dt><span class="property-type">número</span> da carga útil</dt>
<dd>A carga útil <i>tem que</i> ser um número. Qualquer outra coisa tentará ser
analisada gramaticalmente como número e rejeitada se falhar.</dd>
</dl>
<h3>Saídas</h3>
<dl class="message-properties">
<dt><span class="property-type"> número</span> da carga útil</dt>
<dd> O valor mapeado para a novo intervalo.</dd>
</dl>
<h3>Detalhes</h3>
<p>Este nó irá dimensionar linearmente o valor recebido. Por padrão, o resultado
não está restrito ao intervalo definido no nó.</p>
<p><i> Escala e limita ao intervalo de destino </i>significa que o resultado nunca estará fora
do intervalo especificado dentro do intervalo que se quer alcançar.</p>
<p><i>Escala e empacota dentro do intervalo de destino</i> significa que o resultado
será empacotado dentro do intervalo que se quer alcançar.</p>
<p>Por exemplo, uma entrada de 0 - 10 mapeada para 0 - 100.</p>
<table style="outline-width: #888 solid thin">
<tr><th width="80px">modo</th><th width="80px"> entrada </th> <th width="80px"> saída </th></tr>
<tr><td><center>escala</center></td><td><center>12</center></td><td><center>120</center> </td></tr>
<tr><td><center>limite</center></td><td><center>12</center></td><td><center>100</center> </td></tr>
<tr><td><center>empacotamento</center></td><td><center>12</center></td><td><center>20</center></td></tr>
</table>
</script>

55
packages/node_modules/@node-red/nodes/locales/pt-BR/function/80-template.html vendored Normal file
View File

@ -0,0 +1,55 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="template">
<p>Define uma propriedade com base no modelo fornecido.</p>
<h3>Entradas</h3>
<dl class="message-properties">
<dt><span class="property-type">objeto</span> msg</dt>
<dd>Um objeto msg contendo informações para preencher o modelo.</dd>
<dt class="optional">modelo <span class="property-type">string</span></dt>
<dd>Um modelo a ser preenchido em msg.payload. Se não estiver configurado no painel de edição,
o modelo pode ser definido como uma propriedade de msg.</dd>
</dl>
<h3>Saídas</h3>
<dl class="message-properties">
<dt><span class="property-type">objeto</span> msg</dt>
<dd>uma mensagem com uma propriedade definida preenchendo o modelo configurado com as propriedades da mensagem recebida.</dd>
</dl>
<h3>Detalhes</h3>
<p>Por padrão, usa o formato <i> <a href="http://mustache.github.io/mustache.5.html" target="_blank">bigode</a></i>
, mas pode ser desativado, se for necessário.</p>
<p>Por exemplo, quando um modelo de:
<pre>Olá {{payload.name}}. Hoje é {{date}}</pre>
<p> recebe uma mensagem contendo:
<pre> {
date: "segunda-feira",
payload:{
nome: "Fred"
}
} </pre>
<p>A propriedade resultante será:
<pre> Olá Fred. Hoje é segunda-feira</pre>
<p> É possível usar uma propriedade do contexto de fluxo ou contexto global. Basta usar <code>{{flow.name}}</code> ou
<code>{{global.name}}</code>, ou para armazenamento persistente <code>armazenar</code> usando <code>{{flow [store] .name}}</code> ou
<code>{{global [store] .name}}</code>.
<p><b>Nota: </b>Por padrão, <i>bigode</i> usará códigos de escape de quaisquer entidades não alfanuméricas ou HTML nos valores que ele substitui.
Para evitar isso, use colchetes <code>{{{triplos}}}</code>.</p>
<p>Se precisar usar <code>{{ }}</code> em seu conteúdo, você poderá alterar os caracteres
usados para marcar as seções do modelo. Por exemplo, ao invés de utilizar <code>[[ ]]</code>;
adicione a seguinte linha ao topo do modelo:</p>
<pre>{{=[[ ]]=}}</pre>
</script>

64
packages/node_modules/@node-red/nodes/locales/pt-BR/function/89-delay.html vendored Normal file
View File

@ -0,0 +1,64 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="delay">
<p> Atrasa a passagem de cada mensagem pelo nó ou limita a taxa de transmissão. </p>
<h3> Entradas </h3>
<dl class="message-properties">
<dt class="optional">atraso<span class = "property-type"> número </span> </dt>
<dd> Define o atraso, em milissegundos, a ser aplicado à mensagem. este
opção só se aplica se o nó estiver configurado para permitir a mensagem para
sobrescrever o intervalo de atraso padrão configurado. </dd>
<dt class="optional">taxa<span class="property-type"> número</span> </dt>
<dd> Define o valor da taxa em milissegundos entre as mensagens.
Este nó sobrescreve o valor da taxa existente definido na configuração do nó
quando recebe a mensagem que contém o valor <code> msg.rate </code> em miliSegundos.
Esta opção só se aplica se o nó estiver configurado para permitir a mensagem para
sobrescrever o intervalo de taxa padrão configurado. </dd>
<dt class="optional">redefinir</dt>
<dd> Se a mensagem recebida tiver esta propriedade definida para qualquer valor, todos
as mensagens pendentes mantidas pelo nó são apagadas sem serem enviadas. </dd>
<dt class="optional">descarrergar</dt>
<dd> Se a mensagem recebida tiver esta propriedade definida para um valor numérico, então essa quantidade de mensagens
será liberada imediatamente. Se definida para qualquer outro tipo (por exemplo, booliano), então todas as
mensagens pendentes mantidas pelo nó são enviadas imediatamente.</dd>
<dt class="optional">paraFrente</dt>
<dd>Quando em modo de limite de taxa, se a mensagem recebida tiver esta propriedade definida como booliana <code>verdadeira</code>,
então a mensagem é empurrada para a frente da fila e será liberada em seguida.
Isso pode ser usado em combinação com <code>msg.flush=1</code> para reenviar imediatamente.
</dd>
</dl>
<h3>Detalhes</h3>
<p>Quando configurada para atrasar mensagens, o intervalo de atraso pode ser um valor fixo,
um valor aleatório dentro de um intervalo ou definido dinamicamente para cada mensagem.
Cada mensagem é atrasada independentemente de qualquer outra mensagem, com base em
a hora de sua chegada.
</p>
<p> Quando configurada para mensagens de limite de taxa, sua entrega é distribuída
pelo período de tempo configurado. O status mostra o número de mensagens atualmente na fila.
pode-se, opcionalmente, descartar mensagens intermediárias assim que chegarem. </p>
</p>
<p> Se configurada para permitir a substituição da taxa, a nova taxa será aplicada imediatamente,
e permanecerá em vigor até que seja alterada novamente, o nó seja redefinido ou o fluxo seja reiniciado. </p>
<p> A limitação de taxa pode ser aplicada a todas as mensagens ou agrupá-las de acordo com
seu valor <code> msg.topic </code>. Ao agrupar, as mensagens intermediárias são
caiu automaticamente. A cada intervalo de tempo, o nó pode liberar
a mensagem mais recente para todos os tópicos ou libere a mensagem mais recente
para o próximo tópico.
</p>
<p><b>Nota</b>: Em modo de limite de taxa, a profundidade máxima da fila pode ser configurar por uma propriedade no seu arquivo
<i>settings.js</i>. Por exemplo <code>nodeMessageBufferMaxLength: 1000</code></p>
</script>

50
packages/node_modules/@node-red/nodes/locales/pt-BR/function/89-trigger.html vendored Normal file
View File

@ -0,0 +1,50 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="trigger">
<p>Quando acionado, pode enviar uma mensagem e, opcionalmente, uma segunda mensagem, a menos que seja estendida ou redefinida.</p>
<h3>Entradas</h3>
<dl class="message-properties">
<dt class="optional">atraso<span class = "property-type"> número</span></dt>
<dd>Define o atraso, em milissegundos, a ser aplicado à mensagem. Esta opção se aplica apenas se o nó estiver configurado para permitir que a mensagem substitua o intervalo de atraso padrão configurado.</dd>
<dt class="optional">redefinir</dt>
<dd>Se for recebida uma mensagem com esta propriedade, qualquer tempo limite ou repetição
atualmente em andamento será apagado e nenhuma mensagem será acionada.</dd>
</dl>
<h3>Detalhes</h3>
<p>Este nó pode ser usado para criar um tempo limite dentro de um fluxo. Por padrão, quando
ele recebe uma mensagem, ele envia uma mensagem com uma <code>carga útil</code> de<code> 1</code>.
Em seguida, espera 250 ms antes de enviar uma segunda mensagem com uma <code>carga útil</code> de<code> 0</code>.
Isso pode ser usado, por exemplo, para piscar um LED conectado a um pino GPIO Raspberry Pi.</p>
<p>As cargas úteis de cada mensagem enviada podem ser configuradas com uma variedade de valores, incluindo
a opção de não enviar nada. Por exemplo, definir a mensagem inicial como <i>nada</i> e
selecionando a opção de estender o cronômetro com cada mensagem recebida, o nó irá
atuar como um cronômetro de vigilância; apenas enviando uma mensagem se nada for recebido dentro do
limite de intervalo.</p>
<p>Se definido como um tipo <i>cadeia de caractere</i>, o nó dá suporte a sintaxe de modelo bigode.</p>
<p>O atraso entre o envio de mensagens pode ser anulado por <code>msg.delay</code> se essa opção estiver habilitada no nó. O valor deve ser fornecido em milissegundos. </p>
<p>Se o nó receber uma mensagem com uma propriedade <code>reset</code> ou uma <code>carga útil</code>
que corresponda ao configurado no nó, qualquer tempo limite ou repetir atualmente em
o progresso será apagado e nenhuma mensagem será acionada. </p>
<p> O nó pode ser configurado para reenviar uma mensagem em um intervalo regular até que
seja redefinido por uma mensagem recebida.</p>
<p>Opcionalmente, o nó pode ser configurado para tratar as mensagens como se fossem fluxos separados,
usando uma propriedade msg para identificar cada fluxo. <code>msg.topic</code> padrão.</p>
<p>O estado indica que o nó está ativo no momento. Se vários fluxos forem usados, o estado
indica o número de streams em espera.</p>
</script>

83
packages/node_modules/@node-red/nodes/locales/pt-BR/function/90-exec.html vendored Normal file
View File

@ -0,0 +1,83 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="exec">
<p>Executa um comando do sistema e retorna sua saída.</p>
<p>O nó pode ser configurado ou para esperar até que o comando seja concluído ou para
enviar sua saída conforme o comando vai gerando-a.</p>
<p>O comando que é executado pode ser configurado no nó ou fornecido pelo mensagem
recebida.</p>
<h3>Entradas</h3>
<dl class="message-properties">
<dt class="optional">carga útil<span class="property-type"> cadeia de caracteres</span></dt>
<dd>se configurado dessa forma, será adicionado ao final do comando executado.</dd>
<dt class="optional">matar<span class="property-type"> cadeia de caracteres</span></dt>
<dd>o tipo de sinal de eliminação para ser enviado a um processo de nó exec existente.</dd>
<dt class="optional">pid<span class="property-type"> número | cadeia de caracteres</span> </dt>
<dd>o ID do processo de um processo de nó exec existente a ser eliminado.</dd>
</dl>
<h3>Saídas</h3>
<ol class="node-ports">
<li>Saída padrão
<dl class="message-properties">
<dt>carga útil<span class = "property-type"> cadeia de caracteres</span></dt>
<dd>a saída padrão do comando.</dd>
</dl>
<dl class="message-properties">
<dt>rc<span class = "property-type"> objeto</span></dt>
<dd>modo exec apenas, uma cópia do objeto de código de retorno(também disponível na porta 3)</dd>
</dl>
</li>
<li> Erro padrão
<dl class="message-properties">
<dt>carga útil <span class = "property-type"> cadeia de caracteres</span></dt>
<dd>o erro padrão do comando.</dd>
</dl>
<dl class="message-properties">
<dt>rc<span class="property-type"> objeto </span> </dt>
<dd>modo exec apenas, uma cópia do objeto de código de retorno(também disponível na porta 3)</dd>
</dl>
</li>
<li>Código de retorno
<dl class="message-properties">
<dt>carga útil<span class = "property-type"> objeto</span></dt>
<dd>um objeto que contém o código de retorno e, possivelmente,<code> mensagem</code>, propriedades de <code>sinal</code>.</dd>
</dl>
</li>
</ol>
<h3>Detalhes</h3>
<p>Por padrão, usa a chamada do sistema <code>exec</code> que chama o comando, espera que ele seja concluído e, em seguida,
retorna a saída. Por exemplo, um comando bem-sucedido deve ter um código de retorno de <code>{code: 0}</code>.</p>
<p>Opcionalmente, pode usar <code>spawn</code>, que retorna a saída de stdout e stderr
conforme o comando é executado, geralmente uma linha de cada vez. Na conclusão, ele retorna um objeto
na 3ª porta. Por exemplo, um comando bem-sucedido deve retornar <code>{code: 0}</code>.</p>
<p>Os erros podem retornar informações extras na terceira porta <code>msg.payload</code>, como uma cadeia de caracteres do tipo <code>mensagem</code> ou
cadeia de caracteres do tipo <code>sinal</code>.</p>
<p>O comando executado é definido dentro do nó, com uma opção para adicionar <code>msg.payload</code> e um outro conjunto de parâmetros.</p>
<p>Comandos ou parâmetros com espaços devem ser colocados entre aspas - <code>"Este é um parâmetro único"</code></p>
<p>A <code>carga útil</code> retornada é geralmente uma <i> cadeia de caracteres </i>, a menos que caracteres não UTF8 sejam detectados, nesse caso será <i>armazenamento temporário</i>.</p>
<p>O ícone de estado do nó e o PID ficarão visíveis enquanto o nó estiver ativo. As alterações podem ser lidas pelo nó de <code>Estado</code>.</p>
<p>A opção <code>Ocultar console</code> ocultará o console do processo normalmente mostrado em sistemas Windows.</p>
<h4>Processos de morte</h4>
<p> O envio de <code>msg.kill</code> eliminará um único processo ativo. <code>msg.kill</code> deve ser uma cadeia de caracteres contendo
o tipo de sinal a ser enviado, por exemplo, <code>SIGINT</code>, <code>SIGQUIT</code> ou <code>SIGHUP</code>.
O padrão é <code>SIGTERM</code> se definido como uma cadeia de caracteres vazia.</p>
<p>Se o nó tiver mais de um processo em execução, <code>msg.pid</code> também deve ser definido com o valor do PID a ser eliminado.</p>
<p>Se um valor for fornecido no campo <code>Tempo limite</code> então, se o processo não for concluído quando o número especificado de segundos tiver decorrido, o processo será encerrado automaticamente</p>
<p>Dica: se estiver executando um aplicativo Python, você pode precisar usar o parâmetro <code>-u</code> para interromper o armazenamento temporário da saída.</p>
</script>

41
packages/node_modules/@node-red/nodes/locales/pt-BR/function/rbe.html vendored Normal file
View File

@ -0,0 +1,41 @@
<script type="text/html" data-help-name="rbe">
<p>Nó Relatório Por Excessão (RPE) - apenas repassa os dados se a carga útil tiver mudado.
também pode bloquear ao menos, ou ignorar, se o valor mudar devido a uma quantidade específica(modo de banda estreita e morta).</p>
<h3>Entradas</h3>
<dl class="message-properties">
<dt>carga útil
<span class="property-type"> número | cadeia de caracteres | (objeto)</span>
</dt>
<dd>O modo RPE aceita números, cadeia de caracteres e objetos simples.
Outros modos devem fornecer um número analisável sintáticamente.</dd>
<dt class="optional">tópico<span class="property-type">cadeia de caracteres</span>
</dt>
<dd>se especificado, a função funcionará por tópico. Esta propriedade pode ser definida por configuração.</dd>
<dt class="optional">redefinir<span class="property-type">qualquer</span></dt>
<dd>se definido, limpa o valor armazenado para o msg.topic especificado, ou
todos os tópicos se msg.topic não for especificado.</dd>
</dl>
<h3>Saídas</h3>
<dl class="message-properties">
<dt>carga útil
<span class="property-type">conforme entrada</span>
</dt>
<dd>Se acionado, a saída será igual à entrada.</dd>
</dl>
<h3>Detalhes</h3>
<p>No modo RPE, este nó irá bloquear até o valor de <code>msg.payload</code>,
(ou propriedade selecionada) seja diferente do valor anterior.
Se necessário, ele pode ignorar o valor inicial para não enviar nada no início.</p>
<p>Os modos <a href="https://en.wikipedia.org/wiki/Deadband" target="_blank">Bandamorta</a> bloquearão o valor de entrada
<i>a menos que</i> sua alteração seja maior ou maior-igual que &plusmn; a distância da lacuna de banda de um valor anterior.</p>
<p>Os modos de banda estreita bloquearão o valor de entrada,
<i>se</i> sua alteração for maior ou maior-igual que &plusmn; a distância da lacuna de banda de um valor anterior.
É útil para ignorar casos atípicos de um sensor com defeito, por exemplo.</p>
<p>Tanto nos modos de banda morta quanto no de banda estreita, o valor de entrada deve conter um número analisável e
ambos também suportam % - envio apenas se/a menos que a entrada difira em mais de x% do valor original.</p>
<p>Tanto a banda morta quanto a banda estreita permitem a comparação ou com o valor de saída válido anterior, ignorando desse modo
quaisquer valores fora do intervalo, ou com o valor de entrada anterior, que redefine o ponto de ativação, permitindo assim
derivação gradual(banda morta) ou uma mudança de etapa(banda estreita).</p>
<p><b>Nota:</b> isso funciona por base em <code>msg.topic</code>, embora possa ser alterado para outra propriedade, se desejado.
Isso significa que um único nó de filtro pode lidar com vários tópicos diferentes ao mesmo tempo.</p>
</script>

1127
packages/node_modules/@node-red/nodes/locales/pt-BR/messages.json vendored Executable file
View File

File diff suppressed because it is too large Load Diff

19
packages/node_modules/@node-red/nodes/locales/pt-BR/network/05-tls.html vendored Normal file
View File

@ -0,0 +1,19 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="tls-config">
<p>Opções de configuração para conexões TLS.</p>
</script>

22
packages/node_modules/@node-red/nodes/locales/pt-BR/network/06-httpproxy.html vendored Normal file
View File

@ -0,0 +1,22 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="http proxy">
<p>Opções de configuração para proxy HTTP.</p>
<h3>Detalhes</h3>
<p>Ao acessar o servidor na lista de servidores ignorados, nenhum proxy será usado.</p>
</script>

158
packages/node_modules/@node-red/nodes/locales/pt-BR/network/10-mqtt.html vendored Normal file
View File

@ -0,0 +1,158 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="mqtt in">
<p>Conecta-se a um negociante MQTT e assina mensagens do tópico especificado.</p>
<h3>Saídas</h3>
<dl class="message-properties">
<dt>carga útil<span class="property-type"> cadeia de caracteres | armazenament temporário</span></dt>
<dd>uma cadeia de caracteres, a menos que seja detectada como um buffer binário.</dd>
<dt>tópico<span class="property-type"> cadeia de caracteres</span></dt>
<dd>o tópico MQTT, usa / como um separador de hierarquia.</dd>
<dt> qos <span class="property-type"> número</span></dt>
<dd> 0, dispare e esqueça - 1, pelo menos uma vez - 2, uma vez e apenas uma vez.</dd>
<dt>reter<span class="property-type"> booliano</span></dt>
<dd>verdadeiro indica que a mensagem foi retida e pode ser antiga.</dd>
<dt class="optional">responseTopic<span class="property-type">cadeia de caracteres</span></dt>
<dd><b>MQTTv5:</b> o tópico de resposta MQTT para a mensagem</dd>
<dt class="optional">CorrelData <span class="property-type">Armazenamento temporário</span> </dt>
<dd><b>MQTTv5:</b> os dados de correlação para a mensagem</dd>
<dt class="optional">contentType<span class="property-type">cadeia de caracteres</span></dt>
<dd><b>MQTTv5:</b> o tipo de conteúdo da carga útil</dd>
<dt class="optional">userProperties<span class="property-type">objeto</span></dt>
<dd><b>MQTTv5:</b> quaisquer propriedades do usuário da mensagem</dd>
<dt class="optional">messageExpiryInterval<span class="property-type">número</span></dt>
<dd><b>MQTTv5:</b> o tempo de expiração, em segundos, da mensagem</dd>
</dl>
<h3>Detalhes</h3>
O tópico de assinatura pode incluir curingas MQTT, + para um nível, # para vários níveis.</p>
<p>Este nó requer uma conexão com um negociante MQTT para ser configurado. Isso é configurado clicando em
o ícone do lápis.</p>
<p>Vários nós MQTT(dentro ou fora) podem compartilhar a mesma conexão do negociante, se necessário.</p>
<h4>Assinatura dinâmica</h4>
O nó pode ser configurado para controlar dinamicamente a conexão MQTT e suas assinaturas. Quando
habilitado, o nó terá uma entrada e poderá ser controlado passando-lhe mensagens.
<h3>Entradas</h3>
<p>Isso só se aplica quando o nó foi configurado para assinaturas dinâmicas.</p>
<dl class="message-properties">
<dt>ação <span class="property-type">cadeia de caracteres</span></dt>
<dd>o nome da ação que o nó deve executar. As ações disponíveis são: <code>"connect"</code>,
<code>"disconnect"</code>, <code>"subscribe"</code> e <code>"unsubscribe"</code>.</dd>
<dt class="optional">tópico<span class="property-type">cadeia de caracteres|objeto|matriz</span></dt>
<dd>Para as ações <code>"subscribe"</code> e <code>"unsubscribe"</code>, esta propriedade
fornece o tema. Pode ser definido como:<ul>
<li>uma cadeia de caracteres contendo o filtro de tópico</li>
<li>um objeto contendo as propriedades <code>topic</code> e <code>qos</code></li>
<li>uma matriz ou de cadeia de caracteres ou objetos para manusear vários tópicos em um</li>
</ul>
</dd>
<dt class="opcional">negociante<span class="property-type">negociante</span></dt>
<dd>Para a ação <code>"conectar"</code>, esta propriedade pode substituir qualquer
das definições individuais de configuração do negociante, incluindo:<ul>
<li><code>negociante</code></li>
<li><code>porta</code></li>
<li><code>url</code> - substitui o negociante/porta para fornecer uma URL de conexão completa</li>
<li><code>nome de usuário</code></li>
<li><code>senha</code></li>
</ul>
<p>Se esta propriedade estiver configurada e o negociante já estiver conectado, um erro
será registrado a menos que tenha a propriedade <code>force</code> definida - nesse caso, será
desconectado do negociante, aplicada as novas configurações e reconectado.</p>
</dd>
</dl>
</script>
<script type="text/html" data-help-name="mqtt out">
<p>Conecta-se a um negociante MQTT e publica mensagens.</p>
<h3>Entradas</h3>
<dl class="message-properties">
<dt>carga útil <span class="property-type"> cadeia de caracteres | armazenagem temporária</span></dt>
<dd>a carga útil a ser publicada. Se esta propriedade não for configurada, nenhuma mensagem será enviada. Para enviar uma mensagem em branco, defina esta propriedade como uma cadeia de caracteres vazia.</dd>
<dt class="optional">tópico<span class="property-type">cadeia de caracteres</span></dt>
<dd>o tópico MQTT para publicar.</dd>
<dt class="optional">qos<span class="property-type">número</span></dt>
<dd> 0, dispare e esqueça - 1, pelo menos uma vez - 2, uma vez e apenas uma vez. Padrão 0. </dd>
<dt class ="optional">reter<span class="property-type">booliano</span></dt>
<dd>configurado como verdadeiro para reter a mensagem no negociante. O padrão é falso.</dd>
<dt class="optional">responseTopic<span class="property-type">cadeia de caracteres</span></dt>
<dd><b>MQTTv5:</b> o tópico de resposta MQTT para a mensagem</dd>
<dt class="optional">CorrelData<span class="property-type">Armazenamento temporário</span></dt>
<dd><b>MQTTv5:</b> os dados de correlação para a mensagem</dd>
<dt class="optional">contentType<span class="property-type">cadeia de caracteres</span></dt>
<dd><b>MQTTv5:</b> o tipo de conteúdo da carga útil</dd>
<dt class="optional">userProperties<span class="property-type">objeto</span></dt>
<dd><b>MQTTv5:</b> quaisquer propriedades do usuário da mensagem</dd>
<dt class="optional">messageExpiryInterval<span class="property-type">número</span></dt>
<dd><b>MQTTv5:</b> o tempo de expiração, em segundos, da mensagem</dd>
<dt class="optional">topicAlias​​<span class="property-type">número</span></dt>
<dd><b>MQTTv5:</b> o alias do tópico MQTT a ser usado</dd>
</dl>
<h3>Detalhes</h3>
<code>msg.payload</code> é usado como a carga útil da mensagem publicada.
Se contiver um objeto, ele será convertido em uma cadeia de caracteres JSON antes de ser enviado.
Se contiver um armazenamento temporário binário, a mensagem será publicada no estado em que se encontra.</p>
<p>O tópico usado pode ser configurado no nó ou, se deixado em branco, pode ser definido por <code>msg.topic</code>.</p>
<p>Da mesma forma, os valores de QoS e retenção podem ser configurados no nó ou, se deixado
em branco, definido por<code>msg.qos</code> e <code>msg.retain</code> respectivamente. Para limpar um tópico anteriormente
retido pelo negociante, envie uma mensagem em branco para esse tópico com o sinalizador de retenção ativado.</p>
<p>Este nó requer uma conexão com um negociante MQTT para ser configurado. Configura-se o nó clicando
no ícone do lápis.</p>
<p>Vários nós MQTT(dentro ou fora) podem compartilhar a mesma conexão do negociante, se necessário.</p>
<h4>Controle Dinâmico</h4>
A conexão compartilhada pelo nó pode ser controlada dinamicamente. Se o nó receber
uma das seguintes mensagens de controle, ele também não publicará a carga útil da mensagem.
<h3>Entradas</h3>
<dl class="message-properties">
<dt>ação<span class="property-type">cadeia de caracteres</span></dt>
<dd>o nome da ação que o nó deve executar. As ações disponíveis são: <code>"connect"</code>,
e <code>"disconnect"</code>.</dd>
<dt class="opcional">negociante<span class="property-type">negociante</span></dt>
<dd>Para a ação <code>"connect"</code>, esta propriedade pode substituir qualquer
das definições individuais de configuração do negociante, incluindo:<ul>
<li><code>corretor</code></li>
<li><code>porta</code></li>
<li><code>url</code> - substitui o agente/porta para fornecer uma URL de conexão completa</li>
<li><code>nome de usuário</code></li>
<li><code>senha</code></li>
</ul>
<p>Se esta propriedade estiver configurada e o negociante já estiver conectado, um erro
será registrado a menos que tenha a propriedade <code>force</code> definida - nesse caso, será
desconectado do negociante, aplicada as novas configurações e reconectado.</p>
</dd>
</dl>
</script>
<script type="text/html" data-help-name="mqtt-broker">
<p>Configuração para conexão com um negociante MQTT.</p>
<p>Esta configuração criará uma única conexão com o negociante que pode
em seguida, ser reutilizada pelos nós <code>Entrada MQTT</code> e <code>Saída MQTT</code>.</p>
<p>O nó irá gerar um ID de cliente aleatório se nenhum estiver definido e o
o nó está configurado para usar uma conexão de sessão limpa. Se um ID de cliente for definido,
deve ser exclusivo do negociante ao qual você está se conectando.</p>
<h4>Mensagem de nascimento</h4>
<p>Esta é uma mensagem que será publicada no tópico configurado sempre que o
conexão for estabelecida.</p>
<h4>Fechar mensagem</h4>
<p>Esta é uma mensagem que será publicada no tópico configurado antes do
a conexão é fechada normalmente, reimplantando o nó ou desligando. </p>
<H4>Mensagem de arbítrio</h4>
<p>Esta é uma mensagem que será publicada pelo negociante caso o nó
perca sua conexão inesperadamente.</p>
<h4>WebSockets</h4>
<p>O nó pode ser configurado para usar uma conexão WebSocket. Para fazer isso, o campo do servidor
deve ser configurado com uma URI completa para a conexão. Por exemplo:</p>
<pre>ws://example.com:4000/mqtt</pre>
</script>

100
packages/node_modules/@node-red/nodes/locales/pt-BR/network/21-httpin.html vendored Normal file
View File

@ -0,0 +1,100 @@
<!--
copyright js foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="http in">
<p>Cria um ponto de extremidade HTTP para a criação de serviços da web.</p>
<h3>Saídas</h3>
<dl class="message-properties">
<dt>carga útil</dt>
<dd>Para uma solicitação GET, contém um objeto de qualquer parâmetro de cadeia de caracteres de consulta.
Caso contrário, contém o corpo da solicitação HTTP.</dd>
<dt>req <span class="property-type">objeto</span></dt>
<dd>Um objeto de solicitação HTTP. Este objeto contém várias propriedades que
fornecer informações sobre a solicitação.
<ul>
<li><code>body</code> - o corpo da solicitação de entrada. O formato
dependerá da solicitação.</li>
<li><code>headers</code> - um objeto que contém os cabeçalhos de solicitação HTTP.</li>
<li><code>query</code> - um objeto que contém quaisquer parâmetros de string de consulta.</li>
<li><code>params</code> - um objeto que contém quaisquer parâmetros de rota.</li>
<li><code>cookies</code> - um objeto que contém os cookies para a solicitação.</li>
<li><code>arquivos</code> - se habilitado no nó, um objeto contendo
quaisquer arquivos carregados como parte de uma solicitação POST.</li>
</ul>
</dd>
<dt> res <span class="property-type">objeto</span></dt>
<dd>Um objeto de resposta HTTP. Esta propriedade não deve ser usada diretamente;
o nó de <code>Resposta HTTP</code> documenta como responder a uma solicitação.
Esta propriedade deve permanecer anexada à mensagem passada ao nó de resposta.</dd>
</dl>
<h3>Detalhes</h3>
<p>O nó escutará no caminho configurado para solicitações de um tipo particular.
O caminho pode ser totalmente especificado, como <code>/user</code>, ou incluir
parâmetros nomeados que aceitam qualquer valor, como <code>/user/:name</code>.
Quando parâmetros nomeados são usados, seus valores reais em uma solicitação podem ser acessados em <code>msg.req.params</code>.</p>
<p>Para solicitações que incluem um corpo, como POST ou PUT, o conteúdo de
a solicitação é disponibilizada como <code>msg.payload</code>.</p>
<p>Se o tipo de conteúdo da solicitação puder ser determinado, o corpo será analisado sintaticamente para
qualquer tipo apropriado. Por exemplo,<code>application/json</code> será analisado sintaticamente para
sua representação de objeto JavaScript.</p>
<p><b>Nota:</b> este nó não envia nenhuma resposta à solicitação. O fluxo
deve incluir um nó de resposta HTTP para concluir a solicitação.</p>
</script>
<script type="text/html" data-help-name="http response">
<p>Envia respostas de volta às solicitações recebidas de um nó de entrada HTTP.</p>
<h3>Entradas</h3>
<dl class="message-properties">
<dt>carga útil<span class="property-type"> cadeia de caracteres</span></dt>
<dd>O corpo da resposta.</dd>
<dt class="optional">statusCode<span class="property-type"> número</span></dt>
<dd>Se definido, é usado como código de estadi de resposta. Padrão:200.</dd>
<dt class="optional">cabeçalhos<span class="property-type"> objeto</span></dt>
<dd>Se definido, fornece cabeçalhos HTTP para incluir na resposta.</dd>
<dt class="optional">cookies<span class="property-type"> objeto</span></dt>
<dd>Se definido, pode ser usado para definir ou excluir cookies.</dd>
</dl>
<h3>Detalhes</h3>
<p>O <code>statusCode</code> e <code>headers</code> também podem ser definidos dentro
do próprio nó. Se uma propriedade for definida dentro do nó, ela não pode ser substituída
pela propriedade da mensagem correspondente.</p>
<h4>Tratamento de cookies</h4>
<p>A propriedade <code>cookies</code> deve ser um objeto de pares nome/valor.
O valor pode ser uma cadeia de caracteres para definir o valor do cookie com o padrão
opções, ou pode ser um objeto de opções.</p>
<p>O exemplo a seguir define dois cookies - um chamado <code>nome</code> com
um valor de <code>'nick'</code>, o outro chamado <code>session</code> com um
valor de <code>1234</code> e um prazo de validade definido para 15 minutos.</p>
<pre>
msg.cookies = {
name: 'nick',
session: {
value: '1234',
maxAge: 900000
}
}</pre>
<p>As opções válidas incluem:</p>
<ul>
<li><code>domain</code> - (cadeia de caracteres) nome de domínio para o cookie</li>
<li><code>expires</code> - (Data) data de expiração em GMT. Se não for especificado ou definido como 0, cria um cookie de sessão</li>
<li><code>maxAge</code> - (cadeia de caracteres) data de expiração em relação à hora atual em milissegundos</li>
<li><code>path</code> - (cadeia de caracteres) caminho para o cookie. Padrões para /</li>
<li><code>value</code> - (cadeia de caracteres) o valor a ser usado para o cookie</li>
</ul>
<p>Para excluir um cookie, defina seu <code>valor</code> como <code>nulo</code>.</p>
</script>

95
packages/node_modules/@node-red/nodes/locales/pt-BR/network/21-httprequest.html vendored Normal file
View File

@ -0,0 +1,95 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="http request">
<p>Envia solicitações HTTP e retorna a resposta.</p>
<h3>Entradas</h3>
<dl class = "message-properties">
<dt class="optional">url<span class="property-type"> cadeia de caracteres</span></dt>
<dd>Se não for configurada no nó, esta propriedade opcional define o url da solicitação.</dd>
<dt class="optional">método<span class="property-type"> cadeia de caracteres</span></dt>
<dd>Se não for configurada no nó, esta propriedade opcional define o método HTTP da solicitação.
Deve ser <code>GET</code>, <code>PUT</code>, <code>POST</code>, <code>PATCH</code> ou <code>DELETE</code>.</dd>
<dt class="optional">cabeçalhos<span class="property-type"> objeto</span></dt>
<dd>Define os cabeçalhos HTTP da solicitação.</dd>
<dt class="optional">cookies <span class = "property-type"> objeto</span></dt>
<dd>Se definido, pode ser usado para enviar cookies com a solicitação.</dd>
<dt class="optional">carga útil</dt>
<dd>Enviado como o corpo da solicitação.</dd>
<dt class="optional">rejeitarUnauthorized</dt>
<dd>Se definido como <code>falso</code>, permite que as solicitações sejam feitas para sites https que usam
certificados autoassinados.</dd>
<dt class="optional">followRedirects</dt>
<dd>Se definido como <code>falso</code>, evita o redirecionamento seguinte(HTTP 301).<code>verdadeiro</code> por padrão</dd>
<dt class="optional">equestTimeout</dt>
<dd>Se definido como um número positivo de milissegundos, substituirá o parâmetro <code>httpRequestTimeout</code> definido globalmente.</dd>
</dl>
<h3>Saídas</h3>
<dl class="message-properties">
<dt>carga útil <span class="property-type"> cadeia de caracteres | objeto | buffer </span></dt>
<dd>O corpo da resposta. O nó pode ser configurado para retornar o corpo
como uma cadeia de caracteres, tente analisá-la como uma cadeia de caracteres JSON ou deixe-a como um
armazenament temporpario binário.</dd>
<dt>statusCode<span class="property-type">número</span></dt>
<dd>O código de estado da resposta ou o código de erro se a solicitação não pôde ser concluída.</dd>
<dt>headers<span class="property-type">objeto</span></dt>
<dd>Um objeto contendo os cabeçalhos de resposta.</dd>
<dt>responseUrl<span class="property-type">cadeia de caracteres</span></dt>
<dd>Caso ocorram redirecionamentos durante o processamento da solicitação, esta propriedade é a URL redirecionada final.
Caso contrário, o url da solicitação original.</dd>
<dt>responseCookies<span class="property-type">objeto</span></dt>
<dd>Se a resposta incluir cookies, esta propriedade é um objeto de pares nome/valor para cada cookie.</dd>
<dt>redirectList<span class="property-type">matriz</span></dt>
<dd>Se a solicitação foi redirecionada uma ou mais vezes, as informações acumuladas serão adicionadas a esta propriedade. `location` é o próximo destino de redirecionamento. `cookies` são os cookies retornados da fonte de redirecionamento.</dd>
</dl>
<h3>Detalhes</h3>
<p>Quando configurada no nó, a propriedade URL pode conter tags <a href="http://mustache.github.io/mustache.5.html" target="_blank"> estilo bigode</a>. Estes permitem a
url a ser construída utilizando valores da mensagem de entrada. Por exemplo, se o url estiver definido para
<code>example.com/{{{topic}}}</code>, terá o valor de <code>msg.topic</code> inserido automaticamente.
Usar {{{...}}} evita que o bigode use caracteres de escape como /& etc.</p>
<p>O nó pode, opcionalmente, codificar automaticamente <code>msg.payload</code> como parâmetros de cadeia de caracteres de consulta para uma solicitação GET, caso em que <code>msg.payload</code> deve ser um objeto.</p>
<p><b>Nota:</b> Se estiver sendo executado atrás de um proxy, a variável de ambiente <code>http_proxy=...</code> padrão deve ser definida e o Node-RED reiniciado ou use então a configuração de proxy. Se a configuração do proxy foi definida, a configuração tem precedência sobre a variável de ambiente.</p>
<h4>Usando vários nós de solicitação HTTP</h4>
<p>Para usar mais de um desses nós no mesmo fluxo, deve-se ter cuidado com
a propriedade <code>msg.headers</code>. O primeiro nó irá definir esta propriedade com
os cabeçalhos de resposta. O próximo nó usará esses cabeçalhos para sua solicitação - isso
geralmente não é a coisa certa a se fazer. Se a propriedade <code>msg.headers</code> for deixada inalterada
entre os nós, ela será ignorada pelo segundo nó. Para definir cabeçalhos personalizados, <code>msg.headers</code>
deve primeiro ser excluído ou redefinido para um objeto vazio: <code>{}</code>.
<h4>Tratamento de cookies</h4>
<p>A propriedade <code>cookies</code> passada ao nó deve ser um objeto de pares nome/valor.
O valor pode ser uma cadeia de caracteres para definir o valor do cookie ou pode ser um
objeto com uma única propriedade <code>value</code>.</p>
<p>Todos os cookies retornados pela solicitação são devolvidos à propriedade <code>responseCookies</code>.</p>
<h4>Tratamento do tipo de conteúdo</h4>
<p>Se <code>msg.payload</code> for um objeto, o nó definirá automaticamente o tipo de conteúdo
da solicitação para <code>application/json</code> e irá codificar o corpo como tal.</p>
<p>Para codificar a solicitação como dados de formulário, <code>msg.headers["content-type"]</code> deve ser definido como <code>application/x-www-form-urlencoded</code>.</p>
<h4>Subida de arquivo</h4>
<p>Para subir um arquivo, <code>msg.headers["content-type"]</code> deve ser definido como <code>multipart/form-data</code>
e o <code>msg.payload</code> passado para o nó deve ser um objeto com a seguinte estrutura:</p>
<pre><code>{
"KEY": {
"value": FILE_CONTENTS,
"options": {
"filename": "FILENAME"
}
}
}</code></pre>
<p> Os valores de <code>KEY</code>, <code>FILE_CONTENTS</code> e <code>FILENAME</code>
devem ser definidos com os valores apropriados.</p>
</script>

43
packages/node_modules/@node-red/nodes/locales/pt-BR/network/22-websocket.html vendored Normal file
View File

@ -0,0 +1,43 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="websocket in">
<p>Nó Websocket de entrada.</p>
<p>Por padrão, os dados recebidos do WebSocket estarão em <code>msg.payload</code>.
O soquete pode ser configurado para esperar uma cadeia de caracteres JSON formada corretamente, neste
caso, ele irá analisar sintaticamente o JSON e enviar o objeto resultante como a mensagem inteira.</p>
</script>
<script type="text/html" data-help-name="websocket out">
<p>Nó Websocket de saída.</p>
<p>Por padrão, <code>msg.payload</code> será enviado pelo WebSocket. O soquete
pode ser configurado para codificar todo o objeto <code>msg</code> como uma cadeia de caracteres JSON e enviar-lo
pelo WebSocket.</p>
<p>Se a mensagem que chega a este nó for iniciada em um nó WebSocket de entrada, a mensagem
será enviada de volta ao cliente que acionou o fluxo. Caso contrário, a mensagem
será transmitida para todos os clientes conectados.</p>
<p>Se quiser transmitir uma mensagem que começou em um nó WebSocket de entrada, você
deve excluir a propriedade <code>msg._session</code> dentro do fluxo.</p>
</script>
<script type="text/html" data-help-name="websocket-listener">
<p>Este nó de configuração cria uma extremidade do servidor WebSocket usando o caminho especificado.</p>
</script>
<script type="text/html" data-help-name="websocket-client">
<p>Este nó de configuração conecta um cliente WebSocket à URL especificada.</p>
</script>

45
packages/node_modules/@node-red/nodes/locales/pt-BR/network/31-tcpin.html vendored Normal file
View File

@ -0,0 +1,45 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="tcp in">
<p>Oferece uma escolha de entradas TCP. Pode se conectar a uma porta TCP remota,
ou aceitar conexões de entrada.</p>
<p><b>Nota:</b>Em alguns sistemas, você pode precisar de acesso root ou administrador
para acessar as portas abaixo de 1024.</p>
</script>
<script type="text/html" data-help-name="tcp out">
<p>Oferece opções de saídas TCP. Pode se conectar a uma porta TCP remota,
aceitar conexões de entrada ou responder a mensagens recebidas de um nó TCP de entrada.</p>
<p>Apenas o <code>msg.payload</code> é enviado.</p>
<p>Se <code>msg.payload</code> for uma cadeia de caracteres contendo uma codificação binária
de dados Base64, a opção de decodificação Base64 fará com que sejam convertidos de volta para binários
antes de serem enviados.</p>
<p>Se <code>msg._session</code> não estiver presente, a carga útil é
enviada para <b>todos</b> os clientes conectados.</p>
<p><b>Nota:</b> Em alguns sistemas, você pode precisar de acesso root ou administrador
para acessar portas abaixo de 1024.</p>
</script>
<script type="text/html" data-help-name="tcp request">
<p>Um nó de solicitação TCP simples - envia o <code>msg.payload</code> para uma porta tcp do servidor e espera uma resposta.</p>
<p>Conecta, envia a 'solicitação' e lê a 'resposta'. Pode ou contar
o número de caracteres retornados em um armazenamento temporário fixo, igualar a um caractere especificado antes de retornar,
aguardar um tempo limite fixo desde a primeira resposta e depois retornar, sentar-se e esperar pelos dados ou enviar e fechar a conexão
imediatamente, sem esperar uma resposta.</p>
<p>A resposta será produzida em <code>msg.payload</code> como um armazenamento temporário, aí então você pode usar .toString() para converte-la.</p>
<p>Se você deixar o servidor tcp ou a porta em branco, deve-se configurar os mesmos usando as propriedades <code>msg.host</code> e <code>msg.port</code> em cada mensagem enviada ao nó.</p>
</script>

31
packages/node_modules/@node-red/nodes/locales/pt-BR/network/32-udp.html vendored Normal file
View File

@ -0,0 +1,31 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="udp in">
<p>Um nó de entrada UDP, que produz um <code>msg.payload</code> contendo um
armazenamento temporário, cadeia de caracteres ou cadeia de caracteres codificada em base64. Suporta multidifusão.</p>
<p>também fornece <code>msg.ip</code> e <code>msg.port</code> definidos para o
endereço IP e porta de onde a mensagem foi recebida.</p>
<p><b>Nota:</b> Em alguns sistemas, você pode precisar de acesso root ou administrador para usar
portas abaixo de 1024 e/ou transmitir globalmente.</p>
</script>
<script type="text/html" data-help-name="udp out">
<p>Este nó envia <code>msg.payload</code> para o host e porta UDP designados. Suporta multidifusão.</p>
<p>Você também pode usar <code>msg.ip</code> e <code>msg.port</code> para definir os valores de destino, mas os valores configurados estaticamente têm precedência.</p>
<p>Se você selecionar transmistir globalmente, defina o endereço para o endereço IP de transmissão global local ou tente 255.255.255.255, que é o endereço de transmissão global padrão.</p>
<p><b>Nota:</b> Em alguns sistemas, você pode precisar ser root para usar portas abaixo de 1024 e/ou transmitir globalmente.</p>
</script>

49
packages/node_modules/@node-red/nodes/locales/pt-BR/parsers/70-CSV.html vendored Normal file
View File

@ -0,0 +1,49 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="csv">
<p>Converte entre uma cadeia de caracteres formatada em CSV e sua representação de objeto JavaScript, em qualquer direção.</p>
<h3>Entradas</h3>
<dl class="message-properties">
<dt>carga útil <span class="property-type"> objeto | matriz | cadeia de caracteres</span></dt>
<dd>Um objeto JavaScript, matriz ou cadeia de caracteres CSV.</dd>
</dl>
<h3>Saídas</h3>
<dl class="message-properties">
<dt>carga útil <span class="property-type"> objeto | matriz | cadeia de caractere </span></dt>
<dd>
<ul>
<li>Se a entrada for uma cadeia de caracteres, tenta analisá-la sintaticamente como CSV e cria um objeto JavaScript de pares chave/valor para cada linha. O nó enviará então uma mensagem para cada linha, ou uma única mensagem contendo uma matriz de objetos.</li>
<li>Se a entrada for um objeto JavaScript, ela tenta construir uma cadeia de caracteres CSV.</li>
<li>Se a entrada for uma matriz de valores simples, ela cria uma cadeia de caracteres CSV de linha única.</li>
<li>Se a entrada for uma matriz de matrizes ou de objetos, uma cadeia de caracteres CSV de várias linhas é criada.</li>
</ul>
</dd>
</dl>
<h3>Detalhes</h3>
<p>O modelo de coluna pode conter uma lista ordenada de nomes de coluna. Ao converter CSV em um objeto, os nomes das colunas
serão usados como os nomes das propriedades. Como alternativa, os nomes das colunas podem ser obtidos da primeira linha do CSV.</p>
<p>Ao converter para CSV, o modelo de colunas é usado para identificar quais propriedades extrair do objeto e em que ordem.</p>
<p>Se o modelo de colunas estiver em branco, você pode usar uma lista de propriedades simples separada por vírgulas fornecida em <code>msg.columns</code> para determinar o que extrair e em que ordem. Se nenhum estiver presente, todas as propriedades do objeto são exibidas no pedido
em que as propriedades são encontradas na primeira linha.</p>
<p>Se a entrada for uma matriz, o modelo de colunas será usado apenas para gerar opcionalmente uma linha de títulos de coluna.</p>
<p>Se a opção 'analisar valores numéricos' estiver marcada, os valores numéricos da cadeia de caracteres serão retornados como números, ou seja, valor médio '1, '1.5', 2'.</p>
<p>Se a opção 'incluir strings vazias' estiver marcada, strings vazias serão retornadas no resultado, ou seja, valor médio '"1","", 3'.</p>
<p>Se a opção 'incluir valores nulos' estiver marcada, os valores nulos serão retornados no resultado, ou seja, valor médio '"1",,3'.</p>
<p>O nó pode aceitar uma entrada de várias partes, desde que a propriedade <code>partes</code> seja definida corretamente, por exemplo, de um nó de entrada de arquivo ou nó de divisão.</p>
<p>Se forem enviadas várias mensagens de saída, estas terão suas propriedades <code>partes</code> definidas e formarão uma sequência de mensagens completa.</p>
<p><b>Nota:</b> o modelo de coluna deve ser separado por vírgulas - mesmo se um separador diferente for escolhido para os dados.</p>
</script>

36
packages/node_modules/@node-red/nodes/locales/pt-BR/parsers/70-HTML.html vendored Normal file
View File

@ -0,0 +1,36 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="html">
<p>Extrai elementos de um documento html mantido em <code>msg.payload</code> usando um seletor CSS.</p>
<h3>Entradas</h3>
<dl class="message-properties">
<dt>carga útil<span class="property-type">cadeia de caracteres</span></dt>
<dd>a cadeia de caracteres html da qual extrair os elementos.</dd>
<dt class="optional">selecione<span class="property-type"> cadeia de caracteres</span></dt>
<dd>se não for configurado no painel de edição, o seletor pode ser definido como uma propriedade de msg.</dd>
</dl>
<h3>Saída</h3>
<dl class="message-properties">
<dt>carga útil<span class="property-type"> matriz | cadeia de caracteres</span></dt>
<dd>o resultado pode ser ou uma única mensagem com uma carga útil contendo uma matriz dos elementos correspondentes ou várias
mensagens em que cada uma contém um elemento correspondente. Se várias mensagens forem enviadas; estas também terão <code>partes</code> ativadas.</dd>
</dl>
<h3>Detalhes</h3>
<p>Este nó suporta uma combinação de seletores CSS e jQuery. Veja o
<a href="https://github.com/fb55/CSSselect#user-content-supported-selectors" target="_blank">documentação css-select</a> para mais informações
na sintaxe suportada.</p>
</script>

53
packages/node_modules/@node-red/nodes/locales/pt-BR/parsers/70-JSON.html vendored Normal file
View File

@ -0,0 +1,53 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="json">
<p>Converte entre uma cadeia de caracteres JSON e sua representação de objeto JavaScript, em qualquer direção.</p>
<h3>Entradas</h3>
<dl class="message-properties">
<dt>carga útil<span class="property-type">objeto| cadeia de caracteres</span></dt>
<dd>Um objeto JavaScript ou cadeia de caracteres JSON.</dd>
<dt>esquema<span class="property-type">objeto</span></dt>
<dd>Um objeto de esquema JSON opcional para validar a carga útil.
A propriedade será excluída antes que a <code>msg</code> seja enviada para o próximo nó.</dd>
</dl>
<h3>Saídas</h3>
<dl class="message-properties">
<dt>carga útil<span class="property-type">objeto | cadeia de caracteres</span></dt>
<dd>
<ul>
<li>Se a entrada for uma cadeia de caracteres JSON, ela tentará analisá-la sintaticamente como um objeto JavaScript.</li>
<li>Se a entrada for um objeto JavaScript, ela cria uma cadeia de caracteres JSON. A cadeia de caracteres pode ser opcionalmente bem formatada.</li>
</ul>
</dd>
<dt>schemaError<span class="property-type">matriz</span></dt>
<dd>Se a validação do esquema JSON falhar, o nó de captura terá uma propriedade <code>schemaError</code>
contendo uma série de erros.</dd>
</dl>
<h3>Detalhes</h3>
<p>Por padrão, o nó opera em <code>msg.payload</code>, mas pode ser configurado
para converter qualquer propriedade de mensagem.</p>
<p>O nó também pode ser configurado para garantir uma codificação específica em vez de alternar
entre os dois. Isso pode ser usado, por exemplo, com o nó de entrada <code>HTTP</code>
para garantir que a carga útil seja um objeto analisadosintáticamente, mesmo se uma solicitação de entrada
não definir seu tipo de conteúdo corretamente para o nó de entrada HTTP para fazer a conversão.</p>
<p>Se o nó estiver configurado para garantir que a propriedade seja codificada como uma cadeia de caracteres e
que receba a cadeia de caracteres, nenhuma outra verificação será feita na propriedade. Não será
verificado se a cadeia de caracteres é um JSON válido nem será reformatada se a opção de formatar
estive selecionada.</p>
<p> Para obter mais detalhes sobre o esquema JSON, você pode consultar a especificação
<a href="http://json-schema.org/latest/json-schema-validation.html"> aqui</a>.</p>
</script>

50
packages/node_modules/@node-red/nodes/locales/pt-BR/parsers/70-XML.html vendored Normal file
View File

@ -0,0 +1,50 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="xml">
<p>Converte entre uma cadeia de caracteres XML e sua representação de objeto JavaScript, em qualquer direção.</p>
<h3>Entradas</h3>
<dl class="message-properties">
<dt>carga útil<span class="property-type">objeto | cadeia de caracteres</span></dt>
<dd>Um objeto JavaScript ou cadeia de caracteres XML.</dd>
<dt class="optional">opções<span class="property-type">objeto</span></dt>
<dd>Esta propriedade opcional pode ser usada para passar qualquer uma das opções suportadas pelo biblioteca subjacente usada para converter de e para XML. Consulte <a href="https://github.com/Leonidas-from-XIV/node-xml2js/blob/master/README.md#options" target="_blank">os documentos xml2js</a>
para obter maiores informações.</dd>
</dl>
<h3>Saídas</h3>
<dl class="message-properties">
<dt>carga útil<span class="property-type">objeto | cadeia de caracteres </span></dt>
<dd>
<ul>
<li>Se a entrada for uma cadeia de caracteres, tenta-se analisá-la sintáticamente como XML e criar um objeto JavaScript.</li>
<li>Se a entrada for um objeto JavaScript,tenta-se construir uma cadeia de caracteres XML.</li>
</ul>
</dd>
</dl>
<h3>Detalhes</h3>
<p>Ao converter entre XML e um objeto, quaisquer atributos XML são adicionados como uma propriedade chamada <code>$</code> por padrão.
Qualquer conteúdo de texto é adicionado como uma propriedade chamada <code>_</code>. Essas propriedades dos nomes podem ser especificadas na configuração do nó.</p>
<p>Por exemplo, o seguinte XML será convertido conforme mostrado:</p>
<pre>&lt;p class="tag"&gt;Hello World&lt;/p&gt;</pre>
<pre>{
"p": {
"$": {
"class": "tag"
},
"_": "Hello World"
}
}</pre>
</script>

34
packages/node_modules/@node-red/nodes/locales/pt-BR/parsers/70-YAML.html vendored Normal file
View File

@ -0,0 +1,34 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="yaml">
<p>Converte entre uma cadeia de caracteres formatada em YAML e sua representação de objeto JavaScript, em qualquer direção.</p>
<h3>Entradas</h3>
<dl class="message-properties">
<dt>carga útil<span class="property-type">objeto | cadeia de caracteres</span></dt>
<dd>Um objeto JavaScript ou cadeia de caracteres YAML.</dd>
</dl>
<h3>Saídas</h3>
<dl class="message-properties">
<dt>carga útil<span class="property-type"> objeto | cadeia de caracteres</span></dt>
<dd>
<ul>
<li>Se a entrada for uma cadeia de caracteres YAML, tentar-se-a analisá-la sintáticamente como um objeto JavaScript.</li>
<li>Se a entrada for um objeto JavaScript, cria-se uma cadeia de caracteres YAML.</li>
</ul>
</dd>
</dl>
</script>

170
packages/node_modules/@node-red/nodes/locales/pt-BR/sequence/17-split.html vendored Normal file
View File

@ -0,0 +1,170 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="split">
<p>Divide uma mensagem em uma sequência de mensagens.</p>
<h3>Entradas</h3>
<dl class="message-properties">
<dt>carga útil <span class="property-type"> objeto | cadeia de caracteres | matriz | armazenamento temporário </span></dt>
<dd> O comportamento do nó é determinado pelo tipo de<code>msg.payload</code>:
<ul>
<li><b>cadeia de caracteres</b>/<b>armazenamento temporário</b> - a mensagem é dividida usando o caractere especificado (padrão:<code>\n</code>), sequência de armazenamento temporário ou em comprimentos fixos.</li>
<li><b>matriz</b> - a mensagem é dividida em elementos de matriz individuais ou matrizes de comprimento fixo.</li>
<li><b>objeto</b> - uma mensagem é enviada para cada par chave/valor do objeto.</li>
</ul>
</dd>
</dl>
<h3>Saídas</h3>
<dl class="message-properties">
<dt>partes <span class="property-type"> objeto </span></dt>
<dd>Esta propriedade contém informações sobre como a mensagem foi dividida
a partir da mensagem original. Se passado para o nó de <b>junção</b>, a sequência pode ser
remontada em uma única mensagem. A propriedade possui as seguintes propriedades:
<ul>
<li><code>id</code> - um identificador para o grupo de mensagens</li>
<li><code>index</code> - a posição dentro do grupo</li>
<li><code>count</code> - se conhecido, o número total de mensagens no grupo. Consulte 'modo de transmissão' abaixo.</li>
<li><code>type</code> - o tipo de mensagem - cadeia de caracteres / matriz / objeto / armazenamento temporário</li>
<li><code>ch</code> - para uma cadeia de caracteres ou armazenamento temporário, os dados usados ​​para dividir a mensagem como cadeia de caracteres ou uma matriz de bytes</li>
<li><code>key</code> - para um objeto, a chave da propriedade a partir da qual esta mensagem foi criada. O nó pode ser configurado para também copiar este valor para outras propriedades de mensagem, como<code>msg.topic</code>.</li>
<li><code>len</code> - o comprimento de cada mensagem quando dividida usando um valor de comprimento fixo</li>
</ul>
</dd>
</dl>
<h3>Detalhes</h3>
<p>Este nó facilita a criação de um fluxo que executa ações comuns em
uma sequência de mensagens, antes de, usando o nó de <b>junção</b>, recombinar a
seqüência em uma única mensagem.</p>
<p>Ele usa a propriedade<code>msg.parts</code> para rastrear as partes individuais
de uma sequência.</p>
<h4>Modo de transmissão</h4>
<p>O nó também pode ser usado para criar um refluxo de transmissão de mensagens. Por exemplo, um
dispositivo serial que envia comandos terminados em nova linha pode entregar uma única mensagem
com um comando parcial em seu final. No 'modo de trasminssão', este nó irá dividir
uma mensagem e enviar cada segmento completo. Se houver um segmento parcial no final,
o nó irá retê-lo e acrescentá-lo à próxima mensagem que for recebida.
</p>
<p>Ao operar neste modo, o nó não configurará a propriedade<code>msg.parts.count</code>
, pois não sabe quantas mensagens esperar no fluxo. Logo, não pode ser usado com o nó de <b>junção</b> em seu modo automático.</p>
</script>
<script type="text/html" data-help-name="join">
<p>Une sequências de mensagens em uma única mensagem.</p>
<p>Existem três modos disponíveis:</p>
<dl>
<dt>automático</dt>
<dd> Quando emparelhado com o nó de <b>divisão</b>, irá automaticamente juntar as mensagens para reverter a divisão que foi realizada.</dd>
<dt>manual</dt>
<dd> Junta as sequências de mensagens de várias maneiras.</dd>
<dt>reduzir a sequência</dt>
<dd> Aplica uma expressão a todas as mensagens em uma sequência para reduzi-la a uma única mensagem.</dd>
</dl>
<h3>Entradas</h3>
<dl class="message-properties">
<dt class="optional"> partes <span class="property-type"> objeto </span></dt>
<dd>Para unir automaticamente uma sequência de mensagens, todas devem ter
esta propriedade ativida. O nó de <b>divisão</b> gera esta propriedade, mas
pode ser criada manualmente. Possui as seguintes propriedades:
<ul>
<li><code>id</code> - um identificador para o grupo de mensagens</li>
<li><code>index</code> - a posição dentro do grupo</li>
<li><code>contagem</code> - o número total de mensagens no grupo</li>
<li><code>type</code> - o tipo de mensagem - cadeia de caracteres / matriz / objeto / armazenamento temporário</li>
<li><code>ch</code> - para uma cadeia de caracteres ou armazenamento temporário, os dados usados ​​para dividir a mensagem como cadeia de caracteres ou uma matriz de bytes</li>
<li><code>chave</code> - para um objeto, a chave da propriedade a partir da qual esta mensagem foi criada</li>
<li><code>len</code> - o comprimento de cada mensagem dividida usando um valor de comprimento fixo</li>
</ul>
</dd>
<dt class="optional">completo</dt>
<dd>Se definido, o nó acrescentará a carga útil e, em seguida, enviará a mensagem de saída em seu estado atual.
Se você não deseja anexar a carga útil, exclua-a da mensagem.</dd>
<dt class="optional">redefinir</dt>
<dd>Se definido, o nó limpará qualquer mensagem parcialmente completa e não a enviará.</dd>
<dt class="optional">restartTimeout</dt>
<dd>Se definido e o nó tiver um tempo limite configurado, esse tempo limite será reiniciado.</dd>
</dl>
<h3>Detalhes</h3>
<h4>Modo automático</h4>
<p>O modo automático usa a propriedade<code>parts</code> de mensagens recebidas para
determinar como a sequência deve ser unida. Isso permite que ele automaticamente
reverta a ação de um nó <b>dividido</b>.
<h4>Modo manual</h4>
<p>Quando configurado para ingressar no modo manual, o nó é capaz de unir sequências
de mensagens em vários resultados diferentes:</p>
<ul>
<li>uma <b>cadeia de caracteres</b> ou <b>armazenamento temporário</b> - É criada juntando-se a propriedade selecionada de cada mensagem com os caracteres de junção ou armazenamento temporário especificados.</li>
<li>uma <b>matriz</b> - É criada adicionando-se cada propriedade selecionada, ou mensagem inteira, à matriz de saída.</li>
<li>um <b>objeto chave/valor</b> - É criado usando uma propriedade de cada mensagem para determinar sob qual chave
o valor necessário é armazenado.</li>
<li>um <b>objeto mesclado</b> - É criado mesclando a propriedade de cada mensagem em um único objeto.</li>
</ul>
<p>As outras propriedades da mensagem de saída são obtidas a partir da última mensagem recebida antes do resultado ser enviado.</p>
<p>Uma <i>contagem</i> pode ser configurada para quantas mensagens devam ser recebidas antes de gerar a mensagem de saída.
Para saídas de objetos, uma vez que essa contagem tenha sido atingida, o nó pode ser configurado para enviar uma mensagem para cada mensagem subsequente
recebida.</p>
<p>Um <i>tempo limite</i> pode ser definido para acionar o envio da nova mensagem usando o que foi recebido até agora.</p>
<p>Se uma mensagem for recebida com a propriedade <code>msg.complete</code> definida, a mensagem de saída será finalizada e enviada.
Este tempo limite pode ser reiniciado pelo envio de uma mensagem com a propriedade <code>msg.restartTimeout</code> definida.</p>
<p>Se uma mensagem for recebida com a propriedade <code>msg.reset</code> definida, a mensagem parcialmente completa será excluída e não enviada.
Isso redefine qualquer contagem de peças.</p>
<h4>Modo Reduzir Sequência</h4>
<p>Quando configurado para unir no modo de redução, uma expressão é aplicada a cada
mensagem em uma sequência e o resultado acumulado para produzir uma única mensagem.</p>
<dl class="message-properties">
<dt>Valor inicial</dt>
<dd>O valor inicial do valor acumulado (<code>$A</code>).</dd>
<dt>Reduzir a expressão</dt>
<dd>Uma expressão JSONata que é chamada para cada mensagem na sequência.
O resultado é passado para a próxima chamada da expressão como o valor acumulado.
Na expressão em questão, as seguintes variáveis ​​especiais podem ser usadas:
<ul>
<li><code>$A</code>: o valor acumulado,</li>
<li><code>$I</code>: índice da mensagem na sequência,</li>
<li><code>$N</code>: número de mensagens na sequência.</li>
</ul>
</dd>
<dt>Expressão de correção</dt>
<dd>Uma expressão JSONata opcional que é aplicada depois que a expressão de redução
tiver sido aplicado a todas as mensagens na sequência.
Na expressão em questão, as seguintes variáveis ​​especiais podem ser usadas:
<ul>
<li><code>$A</code>: o valor acumulado,</li>
<li><code>$N</code>: número de mensagens na sequência.</li>
</ul>
</dd>
<p>Por padrão, a expressão de redução é aplicada em ordem, desde a primeira
até a última mensagem da sequência. Opcionalmente pode ser aplicada em
ordem inversa.</p>
<p>$N é o número de mensagens que chegam - mesmo que sejam idênticas.</p>
</dl>
<p><b>Exemplo:</b> as configurações a seguir, dada uma sequência de valores numéricos,
calcula o valor médio:
<ul>
<li><b>Reduzir expressão</b>: <code>$A+payload</code></li>
<li><b>Valor inicial</b>: <code>0</code></li>
<li><b>Expressão de correção</b>: <code>$A/$N</code></li>
</ul>
</p>
<h4>Armazenando mensagens</h4>
<p>Este nó armazenará temporariamente de forma interna as mensagens para ir trabalhando através das sequências.
A configuração de tempo de execução <code>nodeMessageBufferMaxLength</code> pode ser usada para limitar quantos nós de mensagens
serão armazenados temporariamente.</p>
</script>

41
packages/node_modules/@node-red/nodes/locales/pt-BR/sequence/18-sort.html vendored Normal file
View File

@ -0,0 +1,41 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="sort">
<p>Uma função que classifica a propriedade da mensagem ou uma sequência de mensagens.</p>
<p>Quando configurado para classificar a propriedade da mensagem, o nó classifica os dados da matriz apontados pela propriedade da mensagem especificada.</p>
<p>Quando configurado para classificar uma sequência de mensagens, reordenará as mensagens.</p>
<p>A ordem de classificação pode ser:</p>
<ul>
<li><b>ascendente</b>,</li>
<li><b>decrescente</b>.</li>
</ul>
<p>Para números, a ordem numérica pode ser especificada por uma caixa de seleção.</p>
<p>A chave de classificação pode ser um valor de elemento ou expressão JSONata para classificar o valor da propriedade, ou propriedade da mensagem ou expressão JSONata para classificar uma sequência de mensagem.</p>
<p>Ao classificar uma sequência de mensagens, o nó de classificação depende das mensagens recebidas para ter <code>msg.parts</code> definido. O nó dividido gera esta propriedade, mas pode ser criado manualmente. Possui as seguintes propriedades:</p>
<p>
<ul>
<li><code>id </code> - um identificador para o grupo de mensagens</li>
<li><code>index </code> - a posição dentro do grupo</li>
<li><code>contagem </code> - o número total de mensagens no grupo</li>
</ul>
</p>
<p><b>Nota:</b> Este nodo internamente mantém mensagens para sua operação. Para evitar o uso inesperado da memória, o número máximo de mensagens mantidas pode ser especificado. O padrão não tem limite do número de mensagens.
<ul>
Propriedade<li><code>nodeMessageBufferMaxLength</code>definida em <b>settings.js</b>.</li>
</ul>
</p>
</script>

43
packages/node_modules/@node-red/nodes/locales/pt-BR/sequence/19-batch.html vendored Normal file
View File

@ -0,0 +1,43 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="batch">
<p>Cria sequências de mensagens com base em várias regras.</p>
<h3>Detalhes</h3>
<p>Existem três modos para criar sequências de mensagens:</p>
<dl>
<dt>Número de mensagens</dt>
<dd>agrupa mensagens em sequências de um determinado comprimento. A opção <b>sobreposição</b>
especifica quantas mensagens no final de uma sequência devem ser
repetidas no início da próxima sequência.</dd>
<dt>Intervalo de tempo</dt>
<dd>agrupa mensagens que chegam dentro do intervalo especificado. Se não houver mensagens
que cheguem dentro do intervalo, o nó pode opcionalmente enviar uma mensagem vazia.</dd>
<dt>Sequências concatenadas</dt>
<dd>cria uma sequência de mensagens concatenando as sequências de entrada. Cada mensagem
deve ter uma propriedade <code>msg.topic</code> e uma propriedade <code>msg.parts</code>
identificando sua seqüência. O nó é configurado com uma lista de valores de <code>tópico</code>
para identificar em que ordem as sequências são concatenados.
</dd>
</dl>
<h4>Armazenamento de mensagens</h4>
<p>Este nó internamente armazenará de forma temporária as mensagens, para que se possam trabalhar as sequências. A
configuração do tempo de execução <code>nodeMessageBufferMaxLength</code> pode ser usada para limitar quantos nós de mensagens
irão criar este armazenamento temporário.</p>
<p>Se uma mensagem for recebida com a propriedade <code>msg.reset</code> definida, as mensagens no armazenamento temporário são excluídas e não enviadas.</p>
</script>

67
packages/node_modules/@node-red/nodes/locales/pt-BR/storage/10-file.html vendored Normal file
View File

@ -0,0 +1,67 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="file">
<p>Grava <code> msg.payload</code> em um arquivo, adicionando ao final ou substituindo o conteúdo existente.
Alternativamente, pode-se excluir o arquivo.</p>
<h3>Entradas</h3>
<dl class="message-properties">
<dt class="optional"> nome do arquivo <span class="property-type"> cadeia de caracteres</span></dt>
<dd> O nome do arquivo a ser atualizado pode ser fornecido na configuração do nó, ou como uma propriedade da mensagem.
Por padrão utilizará <code>msg.filename</code>. Mas, isso pode ser customizado no nó.</dd>
<dt class="optional"> codificação <span class="property-type"> cadeia de caracteres</span></dt>
<dd>Se a codificação estiver configurada para ser definida por msg, então esta propriedade opcional pode definir a codificação.</dt>
</dl>
<h3>Saída</h3>
<p>Ao concluir a gravação, a mensagem de entrada é enviada para a porta de saída.</p>
<h3>Detalhes</h3>
<p>Cada carga útil da mensagem será adicionada ao final do arquivo, opcionalmente anexando
um caractere de nova linha (\n) entre cada um.</p>
<p>Se <code>msg.filename</code> for utilizado, o arquivo será fechado após cada gravação.
Para melhor desempenho, use um nome de arquivo fixo.</p>
<p>Pode ser configurado para sobrescrever o arquivo todo ao invés de ser adicionado ao final. Por exemplo,
ao gravar dados binários em um arquivo, como uma imagem, esta opção deve ser usada
e a opção de adicionar uma nova linha deve ser desativada.</p>
<p>A codificação de dados gravados em um arquivo pode ser especificada na lista de codificações.</p>
<p>Como alternativa, este nó pode ser configurado para excluir o arquivo.</p>
</script>
<script type="text/html" data-help-name="file in">
<p>Lê o conteúdo de um arquivo como cadeia de caracteres ou armazenamento temporário binário.</p>
<h3>Entradas</h3>
<dl class="message-properties">
<dt class="optional">nome do arquivo <span class="property-type">cadeia de caracteres</span></dt>
<dd>O nome do arquivo a ser lido pode ser fornecido na configuração, ou como uma propriedade da mensagem.
Por padrão utilizará <code>msg.filename</code>. Mas, isso pode ser customizado no nó.</dd>
</dl>
<h3>Saídas</h3>
<dl class="message-properties">
<dt>carga útil<span class="property-type"> cadeia de caracteres | armazenamento temporário</span></dt>
<dd>O conteúdo do arquivo como uma cadeia de caracteres ou armazenamento temporário binário.</dd>
<dt class="optional"> nome do arquivo <span class="property-type"> cadeia de caracteres</span></dt>
<dd>Se não estiver configurada no nó, esta propriedade opcional define o nome do arquivo a ser lido.</dd>
</dl>
<h3>Detalhes</h3>
<p>O nome do arquivo deve ser um caminho absoluto, caso contrário, será relativo ao
diretório de trabalho do processo Node-RED.</p>
<p>No Windows, os separadores de caminho podem precisar da sequência de escape, por exemplo: <code>\\Users\\myUser</code>.</p>
<p>Opcionalmente, um arquivo de texto pode ser dividido em linhas, gerando uma mensagem por linha ou um arquivo binário
dividido em blocos menores de armazenamento temporário - o tamanho do bloco depende do sistema operacional, mas normalmente 64k(Linux/Mac) ou 41k(Windows).</p>
<p>Quando dividida em várias mensagens, cada mensagem terá uma propriedade <code> partes</code>
definida, formando uma sequência de mensagem completa.</p>
<p>A codificação dos dados de entrada pode ser especificada na lista de codificações; se o formato de saída for cadeia de caracteres.</p>
<p>Os erros devem ser detectados e tratados usando um nó de Captura.</p>
</script>

30
packages/node_modules/@node-red/nodes/locales/pt-BR/storage/23-watch.html vendored Normal file
View File

@ -0,0 +1,30 @@
<!--
Copyright JS Foundation and other contributors, http://js.foundation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<script type="text/html" data-help-name="watch">
<p>Observa um diretório ou arquivo em busca de alterações.</p>
<p>Você pode inserir uma lista de diretórios e/ou arquivos separados por vírgulas. Você irá
precisa colocar aspas "..." ao redor de qualquer um que tenha espaços.</p>
<p>No Windows, você deve usar barras invertidas duplas \\ em qualquer nome de diretório.</p>
<p>O nome completo do arquivo que realmente mudou é colocado em <code>msg.payload</code> e <code>msg.filename</code>,
enquanto uma versão, em forma de cadeia de caracteres, da lista de observação é retornada em <code>msg.topic</code>.</p>
<p> <code>msg.file</code> contém apenas o nome abreviado do arquivo que foi alterado.
<code>msg.type</code> contem o tipo alterado, geralmente <i>arquivo</i> ou <i>diretório</i>,
enquanto <code>msg.size</code> contém o tamanho do arquivo em bytes.</p>
<p>Claro que no Linux, <i>tudo</i> é um arquivo. Portanto, pode ser observado ... </p>
<p><b>Nota:</b> O diretório ou arquivo deve existir para ser monitorado. Se o arquivo
ou o diretório for excluído, ele não poderá mais ser monitorado, mesmo se for recriado.</p>
</script>

199
packages/node_modules/@node-red/runtime/locales/pt-BR/runtime.json vendored Normal file
View File

@ -0,0 +1,199 @@
{
"runtime": {
"welcome": "Bem vindo ao Node-RED",
"version": "__component__ versão: __version__",
"unsupported_version": "Versão não suportada de __component__. Requer: __requires__ Encontrado: __version__",
"paths": {
"settings": "Arquivo de configurações : __path__",
"httpStatic": "HTTP Estático : __path__"
}
},
"server": {
"loading": "Carregando paletá de nós",
"palette-editor": {
"disabled": "Editor de paletas desativado : configurações do usuário",
"npm-not-found": "Editor de paleta desativado : comando npm não encontrado",
"npm-too-old": "Editor de paleta desativado : versão npm muito antiga. Requer npm> = 3.x"
},
"errors": "Falha ao registrar __count__ tipo de nó",
"errors_plural": "Falha ao registrar __count__ tipos de nós",
"errors-help": "Execute com -v para obter detalhes",
"missing-modules": "Módulos de nó que estão faltando:",
"node-version-mismatch": "O módulo de nó não pode ser carregado nesta versão. Requer: __version__",
"type-already-registered": "'__type__' já registrado pelo módulo __module__",
"removing-modules": "Removendo os módulos da configuração",
"added-types": "Tipos de nós adicionados:",
"removed-types": "Tipos de nós removidos:",
"install": {
"invalid": "Nome de módulo inválido",
"installing": "Módulo de instalação: __name__, versão: __version__",
"installed": "Módulo instalado: __name__",
"install-failed": "Instalação falhou",
"install-failed-long": "Instalação do módulo __name__ falhou:",
"install-failed-not-found": "Módulo $t(server.install.install-failed-long) não encontrado",
"install-failed-name": "$t(server.install.install-failed-long) nome do módulo inválido: __name__",
"install-failed-url": "$t(server.install.install-failed-long) url inválido: __url__",
"post-install-error": "Erro ao executar o gancho 'postInstall':",
"upgrading": "Módulo de atualização: __name__ para a versão: __version__",
"upgraded": "Módulo atualizado: __name__. Reinicie o Node-RED para usar a nova versão",
"upgrade-failed-not-found": "$t(server.install.install-failed-long) versão não encontrada",
"uninstalling": "Desinstalando módulo: __name__",
"uninstall-failed": "Desinstalação falhou",
"uninstall-failed-long": "A desinstalação do módulo __name__ falhou:",
"uninstalled": "Módulo desinstalado: __name__",
"old-ext-mod-dir-warning": "\n\n---------------------------------------------------------------------\ndetectado diretório de módulos externos do Node-RED 1.3:\n __oldDir__\nEste diretório não é mais usado. Módulos externos serão\nreinstalados em seu diretório de usuário Node-RED:\n __newDir__\nExclua o diretório 'externalModules' antigo para interromper esta mensagem.\n---------------------------------------------------------------------\n"
},
"deprecatedOption": "O uso de __old__ está DESCONTINUADO. Use __new__ em seu lugar",
"unable-to-listen": "Incapaz de ouvir em __listenpath__",
"port-in-use": "Erro: porta em uso",
"uncaught-exception": "Exceção não capturada:",
"admin-ui-disabled": "Admin UI desativada",
"now-running": "servidor rodando agora em __listenpath__",
"failed-to-start": "Falhou ao iniciar o servidor:",
"headless-mode": "Executando no modo sem interface gráfica",
"httpadminauth-deprecated": "O uso de 'httpAdminAuth' está DESCONTINUADO. Use 'adminAuth' em seu lugar",
"https": {
"refresh-interval": "Atualizando as configurações de https a cada __interval__ hora(s)",
"settings-refreshed": "As configurações https do servidor foram atualizadas",
"refresh-failed": "Falha ao atualizar as configurações https: __message__",
"nodejs-version": "httpsRefreshInterval requer Node.js 11 ou posterior",
"function-required": "httpsRefreshInterval requer que a propriedade https seja uma função"
}
},
"api": {
"flows": {
"error-save": "Erro ao salvar fluxos: __message__",
"error-reload": "Erro ao recarregar fluxos: __message__"
},
"library": {
"error-load-entry": "Erro ao carregar a entrada da biblioteca '__path__': __message__",
"error-save-entry": "Erro ao salvar a entrada da biblioteca '__path__': __message__",
"error-load-flow": "Erro ao carregar o fluxo '__path__': __message__",
"error-save-flow": "Erro ao salvar o fluxo '__path__': __message__"
},
"nodes": {
"enabled": "Tipos de nós habilitados:",
"disabled": "Tipos de nós desabilitados:",
"error-enable": "Falha ao habilitar o nó:"
}
},
"comms": {
"error": "Erro do canal de comunicação: __message__",
"error-server": "Erro do servidor de comunicação: __message__",
"error-send": "Erro de envio de comunicação: __message__"
},
"settings": {
"user-not-available": "Não é possível salvar as configurações do usuário: __message__",
"not-available": "Configurações não disponíveis",
"property-read-only": "A propriedade '__prop__' é somente leitura",
"readonly-mode": "Execução em modo leitura somente. As alterações não serão salvas."
},
"library": {
"unknownLibrary": "Biblioteca desconhecida: __library__",
"unknownType": "Tipo de biblioteca desconhecido: __type__",
"readOnly": "A biblioteca __library__ é somente de leitura",
"failedToInit": "Falha ao inicializar a biblioteca __library__: __error__",
"invalidProperty": "Propriedade inválida __prop__: '__value__'"
},
"nodes": {
"credentials": {
"error": "Erro ao carregar credenciais: __message__",
"error-saving": "Erro ao salvar credenciais: __message__",
"not-registered": "O tipo de credencial '__type__' não está registrado",
"system-key-warning": "\n\n------------------------------------- --------------------------------\nSeu arquivo de credenciais de fluxo é criptografado usando uma chave gerada pelo sistema.\n\nSe a chave gerada pelo sistema foi perdida por qualquer motivo, seu arquivo de credenciais \nnão será recuperável; você terá que excluí-lo e inserir novamente \nsuas credenciais. \n\nVocê deve definir sua própria chave usando a opção 'credentialSecret' em \n seu arquivo de configurações. O Node-RED irá então criptografar novamente o arquivo de credenciais \n usando a chave escolhida na próxima vez que você implantar uma alteração. \n ------------------- -------------------------------------------------- \n ",
"unencrypted": "Usando credenciais não criptografadas",
"encryptedNotFound": "Credenciais criptografadas não encontradas"
},
"flows": {
"safe-mode": "Fluxos interrompidos no modo de segurança. Implementar para iniciar.",
"registered-missing": "Tipo ausente registrado: __type__",
"error": "Erro ao carregar fluxos: __message__",
"starting-modified-nodes": "Iniciando nós modificados",
"starting-modified-flows": "Iniciando fluxos modificados",
"starting-flows": "Iniciando fluxos",
"started-modified-nodes": "Nós modificados iniciados",
"started-modified-flows": "Fluxos modificados iniciados",
"started-flows": "Fluxos iniciados",
"stopping-modified-nodes": "Parando nós modificados",
"stopping-modified-flows": "Parando fluxos modificados",
"stopping-flows": "Parando fluxos",
"stopped-modified-nodes": "Nós modificados interrompidos",
"stopped-modified-flows": "Fluxos modificados interrompidos",
"stopped-flows": "Fluxos interrompidos",
"stopped": "Parado",
"stopping-error": "Erro ao parar o nó: __message__",
"updated-flows": "Fluxos atualizados",
"added-flow": "Adicionando fluxo: __label__",
"updated-flow": "Fluxo atualizado: __label__",
"removed-flow": "Fluxo removido: __label__",
"missing-types": "Esperando que os tipos ausentes sejam registrados:",
"missing-type-provided": "- __type__ (fornecido pelo módulo npm __module__)",
"missing-type-install-1": "Para instalar qualquer um desses módulos ausentes, execute:",
"missing-type-install-2": "no diretório:"
},
"flow": {
"unknown-type": "Tipo desconhecido: __type__",
"missing-types": "tipos ausentes",
"error-loop": "A mensagem excedeu o número máximo de capturas"
},
"index": {
"unrecognised-id": "Não reconhecido id: __id__",
"type-in-use": "Tipo em uso: __msg__",
"unrecognised-module": "Módulo não reconhecido: __module__"
},
"registry": {
"localfilesystem": {
"module-not-found": "Não é possível encontrar o módulo '__module__'"
}
}
},
"storage": {
"index": {
"forbidden-flow-name": "nome do fluxo proibido"
},
"localfilesystem": {
"user-dir": "Diretório do usuário: __path__",
"flows-file": "Arquivo de fluxos: __path__",
"create": "Criando novo arquivo __type__",
"empty": "O arquivo __type__ existente está vazio",
"invalid": "O arquivo __type__ existente não é json válido",
"restore": "Restaurando backup de arquivo __type__: __path__",
"restore-fail": "Falha ao restaurar o backup do arquivo __type__: __message__",
"fsync-fail": "A liberação do arquivo __path__ para o disco falhou: __message__",
"warn_name": "Nome do arquivo de fluxo não definido. Gerando nome usando o nome do servidor.",
"projects": {
"changing-project": "Configurando projeto ativo: __project__",
"active-project": "Projeto ativo: __projeto__",
"projects-directory": "Diretório de projetos: __projectsDirectory__",
"project-not-found": "Projeto não encontrado: __project__",
"no-active-project": "Nenhum projeto ativo: usando arquivo de fluxos padrão",
"disabled": "Projetos desativados: editorTheme.projects.enabled = false",
"disabledNoFlag": "Projetos desativados: defina editorTheme.projects.enabled = true para ativar",
"git-not-found": "Projetos desativados: comando git não encontrado",
"git-version-old": "Projetos desativados: git __version__ não é compatível. Requer 2.x",
"summary": "Um Projeto Node-RED",
"readme": "### Sobre\n\nEste é o arquivo README.md do seu projeto. O Arquivo ajuda usuários a entender o que seu \nprojeto faz, como usá-lo e qualquer outra coisa que eles precisem saber."
}
}
},
"context": {
"log-store-init": "Armazenamento de contexto: '__name__' [__info__]",
"error-loading-module": "Erro ao carregar armazenamento de contexto: __message__",
"error-loading-module2": "Erro ao carregar o armazenamento de contexto '__module__': __message__",
"error-module-not-defined": "Armazenamento de contexto '__storage__' opção de 'módulo' ausente",
"error-invalid-module-name": "Nome de armazenamento de contexto inválido: '__name__'",
"error-invalid-default-module": "Armazenamento de contexto padrão desconhecido: '__storage__'",
"unknown-store": "Armazenamento de contexto desconhecido '__name__' especificado. Usando armazenamento padrão.",
"localfilesystem": {
"invalid-json": "JSON inválido no arquivo de contexto '__file__'",
"error-circular": "O contexto __scope__ contém uma referência circular que não pode ser continuada",
"error-write": "Erro ao escrever o contexto: __message__"
}
}
}