Migrate from window.electron to tauri IPC functions across components

- Replaced `window.electron.invoke` calls with equivalent `tauri` function calls for all IPC interactions.
- Removed `electron.d.ts` TypeScript definitions as they are no longer needed.
- Updated related logic for offline/online state synchronization.
- Added `types.rs` and `shared/mod.rs` modules to support Tauri IPC integration with Rust enums and shared logic.
- Refactored IPC request queues to use updated handler names for consistency with Tauri.
This commit is contained in:
natreex
2026-03-21 09:34:13 -04:00
parent 1a15692e40
commit ee4438834c
144 changed files with 21258 additions and 876 deletions

View File

@@ -2,6 +2,7 @@
import {useCallback, useContext, useEffect, useState} from 'react';
import {Attribute, CharacterListResponse, CharacterProps} from '@/lib/models/Character';
import {SeriesCharacterProps} from '@/lib/models/Series';
import * as tauri from '@/lib/tauri';
import {SessionContext} from '@/context/SessionContext';
import {BookContext} from '@/context/BookContext';
import {AlertContext} from '@/context/AlertContext';
@@ -147,10 +148,7 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
let response: SeriesCharacterProps[];
// Dual logic: offline ou livre local → IPC, sinon serveur
if (isCurrentlyOffline() || book?.localBook) {
response = await window.electron.invoke<SeriesCharacterProps[]>(
'db:series:character:list',
{seriesId: bookSeriesId}
);
response = await tauri.getSeriesCharacterList(bookSeriesId);
} else {
response = await System.authGetQueryToServer<SeriesCharacterProps[]>(
'series/character/list',
@@ -176,10 +174,7 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
// Series mode - dual logic
let response: SeriesCharacterProps[];
if (isCurrentlyOffline() || localSeries) {
response = await window.electron.invoke<SeriesCharacterProps[]>(
'db:series:character:list',
{seriesId: entityId}
);
response = await tauri.getSeriesCharacterList(entityId);
} else {
response = await System.authGetQueryToServer<SeriesCharacterProps[]>(
'series/character/list',
@@ -231,11 +226,11 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
// Pattern B: GET dans contexte livre
let response: CharacterListResponse;
if (isCurrentlyOffline()) {
// Offline → IPC
response = await window.electron.invoke<CharacterListResponse>('db:character:list', {bookid: entityId});
// Offline → Tauri
response = await tauri.getCharacterList(entityId, true) as CharacterListResponse;
} else if (book?.localBook) {
// Online mais livre local → IPC
response = await window.electron.invoke<CharacterListResponse>('db:character:list', {bookid: entityId});
// Online mais livre local → Tauri
response = await tauri.getCharacterList(entityId, true) as CharacterListResponse;
} else {
// Online + livre serveur → Server
response = await System.authGetQueryToServer<CharacterListResponse>(
@@ -306,15 +301,15 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
let response: boolean;
if (isCurrentlyOffline() || book?.localBook) {
// Offline OU livre local → IPC
response = await window.electron.invoke<boolean>('db:book:tool:update', requestData);
// Offline OU livre local → Tauri
response = await tauri.updateBookToolSetting(requestData.bookId, requestData.toolName, requestData.enabled);
} else {
// Online + livre serveur → Server
response = await System.authPatchToServer<boolean>('book/tool-setting', requestData, userToken, lang);
// Si le livre a une copie locale → addToQueue pour sync
if (book?.bookId && localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === book.bookId)) {
addToQueue('db:book:tool:update', requestData);
addToQueue('update_book_tool_setting', {data: requestData});
}
}
@@ -385,7 +380,7 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
}
};
if (isCurrentlyOffline() || localSeries) {
characterId = await window.electron.invoke<string>('db:series:character:add', seriesCharacterData);
characterId = await tauri.addSeriesCharacter(seriesCharacterData);
} else {
characterId = await System.authPostToServer<string>(
'series/character/add',
@@ -394,7 +389,7 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
lang
);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:character:add', {...seriesCharacterData, id: characterId});
addToQueue('add_series_character', {data: {...seriesCharacterData, id: characterId}});
}
}
} else {
@@ -405,15 +400,15 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
};
if (isCurrentlyOffline() || book?.localBook) {
// Offline OU livre local → IPC
characterId = await window.electron.invoke<string>('db:character:create', requestData);
// Offline OU livre local → Tauri
characterId = await tauri.createCharacter(requestData.character, requestData.bookId, requestData.id);
} else {
// Online + livre serveur → Server
characterId = await System.authPostToServer<string>('character/add', requestData, userToken, lang);
// Si le livre a une copie locale → addToQueue pour sync
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:character:create', {...requestData, id: characterId});
addToQueue('create_character', {data: {...requestData, id: characterId}});
}
}
}
@@ -470,11 +465,11 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
}
};
if (isCurrentlyOffline() || localSeries) {
response = await window.electron.invoke<boolean>('db:series:character:update', updateData);
response = await tauri.updateSeriesCharacter(updateData);
} else {
response = await System.authPatchToServer<boolean>('series/character/update', updateData, userToken, lang);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:character:update', updateData);
addToQueue('update_series_character', {data: updateData});
}
}
} else {
@@ -484,15 +479,15 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
};
if (isCurrentlyOffline() || book?.localBook) {
// Offline OU livre local → IPC
response = await window.electron.invoke<boolean>('db:character:update', requestData);
// Offline OU livre local → Tauri
response = await tauri.updateCharacter(requestData.character);
} else {
// Online + livre serveur → Server
response = await System.authPostToServer<boolean>('character/update', requestData, userToken, lang);
// Si le livre a une copie locale → addToQueue pour sync
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:character:update', requestData);
addToQueue('update_character', {data: requestData});
}
}
}
@@ -529,26 +524,26 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
// Series mode - dual logic
const requestData = {characterId, deletedAt};
if (isCurrentlyOffline() || localSeries) {
response = await window.electron.invoke<boolean>('db:series:character:delete', requestData);
response = await tauri.deleteSeriesCharacter(requestData.characterId, requestData.deletedAt);
} else {
response = await System.authDeleteToServer<boolean>('series/character/delete', requestData, userToken, lang);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:character:delete', requestData);
addToQueue('delete_series_character', {data: requestData});
}
}
} else {
// Pattern A: mutations
const requestData = {characterId, bookId: entityId, deletedAt};
if (isCurrentlyOffline() || book?.localBook) {
// Offline OU livre local → IPC
response = await window.electron.invoke<boolean>('db:character:delete', requestData);
// Offline OU livre local → Tauri
response = await tauri.deleteCharacter(requestData.characterId, requestData.bookId, requestData.deletedAt);
} else {
// Online + livre serveur → Server
response = await System.authDeleteToServer<boolean>('character/delete', requestData, userToken, lang);
// Si le livre a une copie locale → addToQueue pour sync
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:character:delete', requestData);
addToQueue('delete_character', {data: requestData});
}
}
}
@@ -595,25 +590,25 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
if (isSeriesMode) {
// Series mode - dual logic
if (isCurrentlyOffline() || localSeries) {
attributeId = await window.electron.invoke<string>('db:series:character:attribute:add', requestData);
attributeId = await tauri.addSeriesCharacterAttribute(requestData);
} else {
attributeId = await System.authPostToServer<string>('series/character/attribute/add', requestData, userToken, lang);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:character:attribute:add', {...requestData, id: attributeId});
addToQueue('add_series_character_attribute', {data: {...requestData, id: attributeId}});
}
}
} else {
// Pattern A: mutations
if (isCurrentlyOffline() || book?.localBook) {
// Offline OU livre local → IPC
attributeId = await window.electron.invoke<string>('db:character:attribute:add', requestData);
// Offline OU livre local → Tauri
attributeId = await tauri.addCharacterAttribute(requestData.characterId, requestData.type, requestData.name, requestData.id);
} else {
// Online + livre serveur → Server
attributeId = await System.authPostToServer<string>('character/attribute/add', requestData, userToken, lang);
// Si le livre a une copie locale → addToQueue pour sync
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:character:attribute:add', {...requestData, id: attributeId});
addToQueue('add_character_attribute', {data: {...requestData, id: attributeId}});
}
}
}
@@ -658,26 +653,26 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
// Series mode - dual logic
const requestData = {attributeId: attrId, deletedAt};
if (isCurrentlyOffline() || localSeries) {
response = await window.electron.invoke<boolean>('db:series:character:attribute:delete', requestData);
response = await tauri.deleteSeriesCharacterAttribute(requestData.attributeId, requestData.deletedAt);
} else {
response = await System.authDeleteToServer<boolean>('series/character/attribute/delete', requestData, userToken, lang);
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === entityId)) {
addToQueue('db:series:character:attribute:delete', requestData);
addToQueue('delete_series_character_attribute', {data: requestData});
}
}
} else {
// Pattern A: mutations
const requestData = {attributeId: attrId, bookId: entityId, deletedAt};
if (isCurrentlyOffline() || book?.localBook) {
// Offline OU livre local → IPC
response = await window.electron.invoke<boolean>('db:character:attribute:delete', requestData);
// Offline OU livre local → Tauri
response = await tauri.deleteCharacterAttribute(requestData.attributeId, requestData.bookId, requestData.deletedAt);
} else {
// Online + livre serveur → Server
response = await System.authDeleteToServer<boolean>('character/attribute/delete', requestData, userToken, lang);
// Si le livre a une copie locale → addToQueue pour sync
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:character:attribute:delete', requestData);
addToQueue('delete_character_attribute', {data: requestData});
}
}
}
@@ -734,8 +729,8 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
let seriesCharacterId: string;
if (isCurrentlyOffline() || book?.localBook) {
// Mode offline ou livre local → IPC
seriesCharacterId = await window.electron.invoke<string>('db:series:character:add', seriesCharacterData);
// Mode offline ou livre local → Tauri
seriesCharacterId = await tauri.addSeriesCharacter(seriesCharacterData);
} else {
// Mode online → Serveur
seriesCharacterId = await System.authPostToServer<string>(
@@ -746,7 +741,7 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
);
// Si la série a une copie locale → addToQueue
if (localSyncedSeries.find((s: SyncedSeries): boolean => s.id === bookSeriesId)) {
addToQueue('db:series:character:add', {...seriesCharacterData, id: seriesCharacterId});
addToQueue('add_series_character', {data: {...seriesCharacterData, id: seriesCharacterId}});
}
}
@@ -760,14 +755,14 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
let updateResponse: boolean;
if (isCurrentlyOffline() || book?.localBook) {
// Mode offline ou livre local → IPC
updateResponse = await window.electron.invoke<boolean>('db:character:update', updateData);
// Mode offline ou livre local → Tauri
updateResponse = await tauri.updateCharacter(updateData.character);
} else {
// Mode online → Serveur
updateResponse = await System.authPostToServer<boolean>('character/update', updateData, userToken, lang);
// Si le livre a une copie locale → addToQueue
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:character:update', updateData);
addToQueue('update_character', {data: updateData});
}
}
@@ -869,14 +864,14 @@ export function useCharacters(config: UseCharactersConfig): UseCharactersReturn
let characterId: string;
if (isCurrentlyOffline() || book?.localBook) {
// Mode offline ou livre local → IPC
characterId = await window.electron.invoke<string>('db:character:create', requestData);
// Mode offline ou livre local → Tauri
characterId = await tauri.createCharacter(requestData.character, requestData.bookId, requestData.id);
} else {
// Mode online → Serveur
characterId = await System.authPostToServer<string>('character/add', requestData, userToken, lang);
// Si le livre a une copie locale → addToQueue
if (localSyncedBooks.find((sb: SyncedBook): boolean => sb.id === entityId)) {
addToQueue('db:character:create', {...requestData, id: characterId});
addToQueue('create_character', {data: {...requestData, id: characterId}});
}
}