---
title: 'Notion Electron engenharia reversa: prancheta-REA'
url: https://rea.tools/pt-BR/showcase/notion/
---
[Casa](https://rea.tools/pt-BR/) / [Vitrines](https://rea.tools/pt-BR/showcase/) / Notion
Estudo de caso \* Electron
# Como cópias Notion texto e HTML.
Rastreie uma chamada da área de transferência da API da página do Notion, através do processo de pré-carregamento e principal, até o gravador da área de transferência do Electron.
Notion Desktop 7.6.1 · JavaScript \* REA
A ponte dentro do pacote de desktop do Notion
1. 01 \* API Virada Para página
`clipboard.write(data)`
O preload expõe um método chamável.
2. 02 \* invólucro de pré-carga
`ipcRenderer.invoke`
O wrapper envia o canal e os argumentos.
3. 03 \* manipulador do processo principal
`ipcMain.handle`
O destinatário verifica qual página o Enviou.
4. 04 \* área de transferência do sistema
`clipboard.write(data)`
Electron escreve o texto fornecido e HTML.
Um canal une os dois lados: `notion:clipboard:write`
O código empacotado usa o mesmo canal na pré-carga e no processo principal. A resolução dos invólucros revela as chamadas Electron por trás desses nomes.
## Para onde vai a operação de cópia?
A página vê um método chamado `clipboard.write`. Sua implementação na pré-carga é um invólucro. A questão útil é o que esse wrapper envia e qual código o recebe.
O seu agente de codificação
Use REA para rastrear como Notion copia texto e HTML para a área de transferência do sistema. Mostre o código em cada etapa.
Um exemplo de prompt com o pacote de aplicativos locais do Notion disponível para o seu agente de codificação.
### REA descobre por onde começar a ler
A análise da pré-carga da guia com REA localiza a API exposta à página e a chamada que envia uma solicitação IPC. Ambas as descobertas vêm com intervalos de origem no pacote reduzido:
REA constatações intesti dois lugares a abrir
API da página exposta
```
api_key: "__electronApi"
api_status: "dynamic"
source: preload.js:1:22764–22828
```
Chamada IPC do renderizador
```
operation: "invoke"
channel_expression: "e"
source: preload.js:1:6486–6522
```
Campos seleccionados de um novo `analyze_javascript_application` resultado da pré-carga de tabulação do Notion, registado com o REA 4.1.0. As posições usam a linha do pacote original e a coluna baseada em zero.
O agente abre esses locais, localiza o membro da área de transferência na API montada e lê `invokerInMain`. Seu local de chamada fornece `notion:clipboard:write`. Esse nome dá ao agente algo preciso para procurar no pacote principal. Os quatro trechos abaixo mostram a rota que liga.
### Quatro pequenos pedaços de código
Simplificado a partir do pacote JavaScript, com nomes de variáveis legíveis. Os membros independentes são omitidos.
1. #### Comece na API exposta à página
tab_browser_view / preload.js \* membro da API
```
const clipboardApi = {
write: invokerInMain("notion:clipboard:write")
};
// Included in the API exposed through contextBridge:
// window.__electronApi.clipboard
```
Este membro fornece o nome do canal. A aplicação do `invokerInMain` diz-nos como o pedido sai do processo da página.
2. #### Resolver o wrapper da pré-carga
tab_browser_view / preload.js \* IPC helper
```
function invokerInMain(channel) {
return (...args) => invokeInMainAndReturnResult(channel, ...args);
}
function invokeInMainAndReturnResult(channel, ...args) {
return ipcRenderer.invoke(channel, ...args);
}
```
A função devolvida encaminha os argumentos através do IPC de pedido e resposta do Electron. Podemos agora procurar `notion:clipboard:write` do lado do processo principal.
3. #### Verificar como o recetor está registado
principal/index.js \* handler helper
```
const handleRequestFromRenderer = {
addListener(channel, handler) {
ipcMain.handle(channel, handler);
}
};
```
O processo principal utiliza outro invólucro. Sua `addListener` o método regista uma `ipcMain.handle` receptor para esse canal.
4. #### Encontre a gravação e a verificação do remetente
principal/index.js \* receptor da área de transferência
```
handleRequestFromRenderer.addListener(
"notion:clipboard:write",
(event, data) =>
isNotionWebContents(event.sender)
? clipboard.write(data)
: undefined
);
```
Este é o destino. Depois de verificar o remetente, o manipulador passa os dados fornecidos para a API da área de transferência do Electron. O canal e os dois wrappers resolvidos conectam o método exposto a esta chamada.
## Como é que um bloco copiado mantém a sua estrutura?
O editor web do Notion envia texto e HTML através de `electronApi.clipboard.write`. Ele mantém os dados do bloco localmente e coloca um ID no HTML copiado para conectá-los.
Links HTML para dados de bloco salvos
Enviado para a área de transferência do sistema
```
text: "Project notes"
html: "Project notes
"
+ ""
```
Salvo localmente por Notion
```
id:
mimeTypes:
text/_notion-blocks-v3-production
→ structured block data
```
1. Leia o ID HTML
2. Encontre o mesmo ID local
3. Restaurar dados do bloco Notion
Texto ilustrativo e ID. O teste do módulo gravado restaura os dados do bloco quando os IDs correspondem; uma entrada obsoleta retorna apenas texto e HTML.
Ao colar, Notion procura o ID HTML e verifica-o em relação à cópia salva. Os IDs correspondentes restauram os dados do bloco.
Formato da área de transferência gravado a partir de ativos da web armazenados em cache em 13 de julho de 2026.
## Mais exemplos e fontes
Outro exemplo: tabelas de remarcação
Notion analisa Markdown em dados de bloco. Este exemplo mostra como uma tabela se torna cabeçalho e linhas de dados.
Uma tabela através do analisador Markdown do Notion
Entrada de redução
```
| A | B |
| - | - |
| 1 | 2 |
```
Saída do analisador estruturado \* excerto
```
table · headerRow: true
table_row
cells: ["A"], ["B"]
table_row
cells: ["1"], ["2"]
```
Saída gravada de um analisador Markdown extraído. A tabela torna-se linhas e células.
Outro caminho: a conexão SQLite offline
Pedidos do renderizador Notion `getSqliteMeta` através do IPC. O processo principal cria um canal de mensagem e fornece uma porta ao renderizador e a outra a um processo utilitário SQLite. Os lotes de declaração subsequentes e os resultados percorrem esse Porto.
Após esta transferência, explica onde o trabalho do banco de dados é executado e por que o rastreamento apenas da solicitação IPC inicial perde a conversa posterior.
Fontes e como ler os excertos
A Ponte da área de transferência vem do Notion Desktop 7.6.1 `app.asar`: a pré-carga do separador e `main/index.js`. Os excertos expandem nomes de variáveis minimizados e omitem código não relacionado; o auxiliar sender-check é mostrado com seu subjacente `isNotionWebContents` telefona.
Os exemplos de prancheta virtual e Markdown vêm de ativos da web armazenados em cache em 13 de julho de 2026, incluindo módulos `747001`, `58169`, `736810` e `422457`. Esses activos têm a sua própria versão. As sondas salvas executaram módulos extraídos e pequenos chicotes de fios; suas saídas descrevem essas sondas em vez de uma sessão de interface do usuário da área de trabalho capturada.
O resultado REA mostrado aqui é uma análise focada da pré-carga de tabulação guardada, registada com o pacote REA 4.1.0 publicado. Ele localiza a API e invoca a operação. O membro da área de transferência e o receptor correspondente são conectados lendo suas implementações de wrapper no Pacote.
O exemplo Markdown usa o módulo parser `422457`. Os testes de Módulo salvos mostram que os filtros de página e de bate-papo preservam essa tabela. Os analisadores paste/import, structured Markdown e AI/chat têm pontos de entrada separados e formatos intermédios.
- [Guia de Aplicação JavaScript](https://rea.tools/guides/javascript/)Siga o recurso de exportação de um pequeno aplicativo Electron.
- [Reconstrução DX-Ball](https://rea.tools/pt-BR/showcase/dx-ball/)Siga as instruções nativas para uma função C verificada.
[Analise seu próprio aplicativo](https://rea.tools/get-started/)