Add offline mode logic for book, story, and world operations

- Integrate `OfflineContext` into book, story settings, and related components.
- Add conditional logic to toggle between server API requests and offline IPC handlers (`db:book:delete`, `db:book:story:get`, `db:location:all`, etc.).
- Refactor and update IPC handlers to accept structured data arguments for improved consistency (`data: object`).
- Ensure stricter typings in IPC handlers and frontend functions.
- Improve error handling and user feedback in both online and offline modes.

components/book/settings/world/WorldElement.tsx

@@ -11,6 +11,7 @@ import System from "@/lib/models/System";
 import InputField from "@/components/form/InputField";
 import {useTranslations} from "next-intl";
 import {LangContext, LangContextProps} from "@/context/LangContext";
+import OfflineContext, {OfflineContextType} from "@/context/OfflineContext";
 
 interface WorldElementInputProps {
     sectionLabel: string;
@@ -20,6 +21,7 @@ interface WorldElementInputProps {
 export default function WorldElementComponent({sectionLabel, sectionType}: WorldElementInputProps) {
     const t = useTranslations();
     const {lang} = useContext<LangContextProps>(LangContext);
+    const {isCurrentlyOffline} = useContext<OfflineContextType>(OfflineContext);
     const {worlds, setWorlds, selectedWorldIndex} = useContext(WorldContext);
     const {errorMessage, successMessage} = useContext(AlertContext);
     const {session} = useContext(SessionContext);
@@ -31,9 +33,17 @@ export default function WorldElementComponent({sectionLabel, sectionType}: World
         index: number,
     ): Promise<void> {
         try {
-            const response: boolean = await System.authDeleteToServer<boolean>('book/world/element/delete', {
-                elementId: (worlds[selectedWorldIndex][section] as WorldElement[])[index].id,
-            }, session.accessToken, lang);
+            let response: boolean;
+            const elementId = (worlds[selectedWorldIndex][section] as WorldElement[])[index].id;
+            if (isCurrentlyOffline()) {
+                response = await window.electron.invoke<boolean>('db:book:world:element:remove', {
+                    elementId: elementId,
+                });
+            } else {
+                response = await System.authDeleteToServer<boolean>('book/world/element/delete', {
+                    elementId: elementId,
+                }, session.accessToken, lang);
+            }
             if (!response) {
                 errorMessage(t("worldSetting.unknownError"))
             }
@@ -58,11 +68,20 @@ export default function WorldElementComponent({sectionLabel, sectionType}: World
             return;
         }
         try {
-            const elementId: string = await System.authPostToServer('book/world/element/add', {
-                elementType: section,
-                worldId: worlds[selectedWorldIndex].id,
-                elementName: newElementName,
-            }, session.accessToken, lang);
+            let elementId: string;
+            if (isCurrentlyOffline()) {
+                elementId = await window.electron.invoke<string>('db:book:world:element:add', {
+                    elementType: section,
+                    worldId: worlds[selectedWorldIndex].id,
+                    elementName: newElementName,
+                });
+            } else {
+                elementId = await System.authPostToServer('book/world/element/add', {
+                    elementType: section,
+                    worldId: worlds[selectedWorldIndex].id,
+                    elementName: newElementName,
+                }, session.accessToken, lang);
+            }
             if (!elementId) {
                 errorMessage(t("worldSetting.unknownError"))
                 return;

components/book/settings/world/WorldSetting.tsx

@@ -16,6 +16,7 @@ import WorldElementComponent from './WorldElement';
 import SelectBox from "@/components/form/SelectBox";
 import {useTranslations} from "next-intl";
 import {LangContext, LangContextProps} from "@/context/LangContext";
+import OfflineContext, {OfflineContextType} from "@/context/OfflineContext";
 
 export interface ElementSection {
     title: string;
@@ -26,6 +27,7 @@ export interface ElementSection {
 export function WorldSetting(props: any, ref: any) {
     const t = useTranslations();
     const {lang} = useContext<LangContextProps>(LangContext);
+    const {isCurrentlyOffline} = useContext<OfflineContextType>(OfflineContext);
     const {errorMessage, successMessage} = useContext(AlertContext);
     const {session} = useContext(SessionContext);
     const {book} = useContext(BookContext);
@@ -49,9 +51,14 @@ export function WorldSetting(props: any, ref: any) {
     
     async function getWorlds() {
         try {
-            const response: WorldProps[] = await System.authGetQueryToServer<WorldProps[]>(`book/worlds`, session.accessToken, lang, {
-                bookid: bookId,
-            });
+            let response: WorldProps[];
+            if (isCurrentlyOffline()) {
+                response = await window.electron.invoke<WorldProps[]>('db:book:worlds:get', {bookid: bookId});
+            } else {
+                response = await System.authGetQueryToServer<WorldProps[]>(`book/worlds`, session.accessToken, lang, {
+                    bookid: bookId,
+                });
+            }
             if (response) {
                 setWorlds(response);
                 const formattedWorlds: SelectBoxProps[] = response.map(
@@ -77,10 +84,18 @@ export function WorldSetting(props: any, ref: any) {
             return;
         }
         try {
-            const worldId: string = await System.authPostToServer<string>('book/world/add', {
-                worldName: newWorldName,
-                bookId: bookId,
-            }, session.accessToken, lang);
+            let worldId: string;
+            if (isCurrentlyOffline()) {
+                worldId = await window.electron.invoke<string>('db:book:world:add', {
+                    worldName: newWorldName,
+                    bookId: bookId,
+                });
+            } else {
+                worldId = await System.authPostToServer<string>('book/world/add', {
+                    worldName: newWorldName,
+                    bookId: bookId,
+                }, session.accessToken, lang);
+            }
             if (!worldId) {
                 errorMessage(t("worldSetting.addWorldError"));
                 return;
@@ -125,10 +140,18 @@ export function WorldSetting(props: any, ref: any) {
     
     async function handleUpdateWorld(): Promise<void> {
         try {
-            const response: boolean = await System.authPutToServer<boolean>('book/world/update', {
-                world: worlds[selectedWorldIndex],
-                bookId: bookId,
-            }, session.accessToken, lang);
+            let response: boolean;
+            if (isCurrentlyOffline()) {
+                response = await window.electron.invoke<boolean>('db:book:world:update', {
+                    world: worlds[selectedWorldIndex],
+                    bookId: bookId,
+                });
+            } else {
+                response = await System.authPutToServer<boolean>('book/world/update', {
+                    world: worlds[selectedWorldIndex],
+                    bookId: bookId,
+                }, session.accessToken, lang);
+            }
             if (!response) {
                 errorMessage(t("worldSetting.updateWorldError"));
                 return;