---
title: 'Notion Electron Reverse Engineering: Appunti-REA'
url: https://rea.tools/it/showcase/notion/
---
[Casa](https://rea.tools/it/) / [Vetrina](https://rea.tools/it/showcase/) / Notion
Caso di studio \* Electron
# Come copie Notion testo e HTML.
Traccia una chiamata negli appunti dall'API della pagina di Notion, attraverso il precarico e il processo principale, allo scrittore degli appunti di Electron.
Notion Desktop 7.6.1 · JavaScript · REA
Il ponte all'interno del pacchetto desktop Notion
1. 01 \* API rivolta verso la pagina
`clipboard.write(data)`
Il precarico espone un metodo richiamabile.
2. 02 \* Precarico involucro
`ipcRenderer.invoke`
Il wrapper invia il canale e gli argomenti.
3. 03 \* Gestore del processo principale
`ipcMain.handle`
Il destinatario controlla quale pagina l'ha inviata.
4. 04 \* Appunti di sistema
`clipboard.write(data)`
Electron scrive il testo e l'HTML forniti.
Un canale unisce i due lati: `notion:clipboard:write`
Il codice pacchettizzato utilizza lo stesso canale nel processo di precarico e principale. La risoluzione dei wrapper rivela le chiamate Electron dietro quei nomi.
## Dove va l'operazione di copia?
La pagina vede un metodo chiamato `clipboard.write`. La sua implementazione nel precarico è un wrapper. La domanda utile è cosa invia quel wrapper e quale codice lo riceve.
Il tuo agente di codifica
Utilizzare REA per tracciare come Notion copia testo e HTML negli appunti di sistema. Mostra il codice ad ogni passaggio.
Un prompt di esempio con il pacchetto di applicazioni locali di Notion disponibile per l'agente di codifica.
### REA trova dove iniziare a leggere
Analizzando il precarico scheda con REA individua l'API esposta alla pagina e la chiamata che invia una richiesta IPC. Entrambi i risultati sono dotati di intervalli di origine nel pacchetto minificato:
REA risultati → due posti da aprire
API pagina esposta
```
api_key: "__electronApi"
api_status: "dynamic"
source: preload.js:1:22764–22828
```
Renderer Chiamata IPC
```
operation: "invoke"
channel_expression: "e"
source: preload.js:1:6486–6522
```
Campi selezionati da un fresco `analyze_javascript_application` risultato sul precarico scheda di Notion, registrato con REA 4.1.0. Le posizioni utilizzano la linea e la colonna zero del bundle originale.
L'agente apre tali posizioni, trova il membro degli appunti nell'API assemblata e legge `invokerInMain`. Il suo sito di chiamata fornisce `notion:clipboard:write`. Quel nome dà all'agente qualcosa di preciso da cercare nel pacchetto principale. I quattro estratti qui sotto mostrano il percorso che collega.
### Quattro brevi pezzi di codice
Semplificato dal pacchetto JavaScript, con nomi di variabili leggibili. I membri non correlati sono omessi.
1. #### Inizia dall'API esposta alla pagina
tab_browser_view/preload.js \* Membro API
```
const clipboardApi = {
write: invokerInMain("notion:clipboard:write")
};
// Included in the API exposed through contextBridge:
// window.__electronApi.clipboard
```
Questo membro fornisce il nome del canale. L'attuazione di `invokerInMain` ci dice come la richiesta lascia il processo della pagina.
2. #### Risolvere il wrapper del precarico
tab_browser_view/preload.js \* IPC helper
```
function invokerInMain(channel) {
return (...args) => invokeInMainAndReturnResult(channel, ...args);
}
function invokeInMainAndReturnResult(channel, ...args) {
return ipcRenderer.invoke(channel, ...args);
}
```
La funzione restituita inoltra gli argomenti tramite IPC di richiesta e risposta di Electron. Ora possiamo cercare `notion:clipboard:write` dal lato del processo principale.
3. #### Controlla come è registrato il ricevitore
principale/index.js \* handler helper
```
const handleRequestFromRenderer = {
addListener(channel, handler) {
ipcMain.handle(channel, handler);
}
};
```
Il processo principale utilizza un altro wrapper. Sua `addListener` metodo registra un `ipcMain.handle` ricevitore per quel canale.
4. #### Trova la scrittura e il suo controllo mittente
principale/index.js \* ricevitore appunti
```
handleRequestFromRenderer.addListener(
"notion:clipboard:write",
(event, data) =>
isNotionWebContents(event.sender)
? clipboard.write(data)
: undefined
);
```
Questa è la destinazione. Dopo aver controllato il mittente, il gestore passa i dati forniti all'API degli appunti di Electron. Il canale e i due wrapper risolti collegano il metodo esposto a questa chiamata.
## In che modo un blocco copiato mantiene la sua struttura?
L'editor web di Notion invia testo e HTML attraverso `electronApi.clipboard.write`. Mantiene i dati del blocco localmente e inserisce un ID nell'HTML copiato per collegarli.
Collegamenti HTML ai dati di blocco salvati
Inviato agli appunti di sistema
```
text: "Project notes"
html: "Project notes
"
+ ""
```
Salvato localmente da Notion
```
id:
mimeTypes:
text/_notion-blocks-v3-production
→ structured block data
```
1. Leggi l'ID HTML
2. Trova lo stesso ID locale
3. Ripristinare i dati del blocco Notion
Testo illustrativo e ID. Il test del modulo registrato ripristina i dati del blocco quando gli ID corrispondono; una voce obsoleta restituisce solo testo e HTML.
In incolla, Notion cerca l'ID HTML e lo controlla rispetto alla copia salvata. Gli ID corrispondenti ripristinano i dati del blocco.
Formato appunti registrato da risorse Web memorizzate nella cache il 13 luglio 2026.
## Altri esempi e fonti
Un altro esempio: tabelle Markdown
Notion analizza Markdown in dati di blocco. Questo esempio mostra come una tabella diventa intestazione e righe di dati.
Una tabella attraverso il parser Markdown di Notion
Ingresso markdown
```
| A | B |
| - | - |
| 1 | 2 |
```
Uscita parser strutturata \* estratto
```
table · headerRow: true
table_row
cells: ["A"], ["B"]
table_row
cells: ["1"], ["2"]
```
Uscita registrata da un parser Markdown estratto. La tabella diventa righe e celle.
Un altro percorso: la connessione SQLite offline
Richieste di rendering di Notion `getSqliteMeta` attraverso IPC. Il processo principale crea un canale di messaggi e fornisce una porta al renderer e l'altra a un processo di utilità SQLite. I successivi lotti di istruzione e i risultati viaggiano su quella porta.
In seguito a questo handoff spiega dove viene eseguito il lavoro del database e perché tracciare solo la richiesta IPC iniziale manca la conversazione successiva.
Fonti e come leggere gli estratti
Il ponte degli appunti proviene da Notion Desktop 7.6.1 `app.asar`: la scheda precarico e `main/index.js`. Gli estratti espandono i nomi delle variabili minificate e omettono codice non correlato; l'helper sender-check viene mostrato con il suo sottostante `isNotionWebContents` chiamare.
Gli esempi di Appunti virtuali e Markdown provengono da risorse Web memorizzate nella cache il 13 luglio 2026, inclusi i moduli `747001`, `58169`, `736810` e `422457`. Tali risorse hanno una loro versione. Le sonde salvate hanno eseguito moduli estratti e piccoli cablaggi; i loro output descrivono quelle sonde piuttosto che una sessione di interfaccia utente desktop catturata.
Il risultato REA mostrato qui è un'analisi mirata del precarico scheda salvato, registrato con il pacchetto REA 4.1.0 pubblicato. Individua l'API e richiama l'operazione. Il membro degli appunti e il ricevitore corrispondente sono collegati leggendo le loro implementazioni wrapper nel pacchetto.
L'esempio di Markdown utilizza il modulo parser `422457`. I test dei moduli salvati mostrano che entrambi i filtri di pagina e chat conservano questa tabella. I parser paste/import, structured Markdown e AI/chat hanno punti di ingresso separati e formati intermedi.
- [Guida all'applicazione JavaScript](https://rea.tools/guides/javascript/)Seguire la funzione di esportazione di una piccola applicazione Electron.
- [DX-Ball ricostruzione](https://rea.tools/it/showcase/dx-ball/)Seguire le istruzioni native per una funzione C selezionata.
[Analizza la tua app](https://rea.tools/get-started/)