create-pixi-vn 2.0.14 → 2.1.0

package/template-nqtr-react-vite-muijoy/src/lib/utils/db-utility.ts

@@ -0,0 +1,204 @@
+const INDEXED_DB_VERSION = 2; // Increment this version number when you change the database schema
+const INDEXED_DB_NAME = "game_db";
+export const INDEXED_DB_SAVE_TABLE = "saves";
+
+export function initializeIndexedDB(): Promise<void> {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(INDEXED_DB_NAME, INDEXED_DB_VERSION);
+        // check if the object store exists
+        request.onupgradeneeded = (_event) => {
+            const db = request.result;
+            if (!db.objectStoreNames.contains(INDEXED_DB_SAVE_TABLE)) {
+                // create the object store
+                const objectStore = db.createObjectStore(INDEXED_DB_SAVE_TABLE, {
+                    keyPath: "id",
+                    autoIncrement: true,
+                });
+                objectStore.createIndex("id", "id", { unique: true });
+                objectStore.createIndex("date", "date", { unique: false });
+                objectStore.createIndex("name", "name", { unique: false });
+                objectStore.createIndex("gameVersion", "gameVersion", { unique: false });
+            }
+        };
+
+        request.onsuccess = (_event) => {
+            resolve();
+        };
+        request.onerror = (event) => {
+            console.error("Error opening indexDB", event);
+            reject();
+        };
+    });
+}
+
+export async function putRowIntoIndexDB<T extends {}>(tableName: string, data: T): Promise<T> {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(INDEXED_DB_NAME);
+
+        request.onsuccess = (_event) => {
+            const db = request.result;
+            // run onupgradeneeded before onsuccess
+            if (!db.objectStoreNames.contains(tableName)) {
+                console.error("Object store rescues does not exist");
+                reject();
+            }
+            const transaction = db.transaction([tableName], "readwrite");
+            const objectStore = transaction.objectStore(tableName);
+            const setRequest = objectStore.put(data);
+            setRequest.onsuccess = (_event) => {
+                resolve(data);
+            };
+            setRequest.onerror = (event) => {
+                console.error("Error adding save data to indexDB", event);
+                reject();
+            };
+        };
+        request.onerror = (event) => {
+            console.error("Error adding save data to indexDB", event);
+        };
+    });
+}
+
+export async function getRowFromIndexDB<T extends {}>(
+    tableName: string,
+    id: number | string,
+): Promise<T | null> {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(INDEXED_DB_NAME);
+        request.onsuccess = (_event) => {
+            const db = request.result;
+            // check if the object store exists
+            if (!db.objectStoreNames.contains(tableName)) {
+                resolve(null);
+                return;
+            }
+            const transaction = db.transaction([tableName], "readwrite");
+            const objectStore = transaction.objectStore(tableName);
+            const getRequest = objectStore.get(id);
+            getRequest.onsuccess = (_event) => {
+                resolve(getRequest.result);
+            };
+            getRequest.onerror = (event) => {
+                console.error("Error getting save data from indexDB", event);
+                reject();
+            };
+        };
+        request.onerror = (event) => {
+            console.error("Error opening indexDB", event);
+            reject();
+        };
+    });
+}
+
+export async function getLastRowFromIndexDB<T extends {}>(tableName: string): Promise<T | null> {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(INDEXED_DB_NAME);
+        request.onsuccess = (_event) => {
+            const db = request.result;
+            // check if the object store exists
+            if (!db.objectStoreNames.contains(tableName)) {
+                resolve(null);
+                return;
+            }
+            const transaction = db.transaction([tableName], "readwrite");
+            const objectStore = transaction.objectStore(tableName);
+            const getRequest = objectStore.openCursor(null, "prev");
+            getRequest.onsuccess = (_event) => {
+                const cursor = getRequest.result;
+                if (cursor) {
+                    resolve(cursor.value);
+                } else {
+                    resolve(null);
+                }
+            };
+            getRequest.onerror = (event) => {
+                console.error("Error getting save data from indexDB", event);
+                reject();
+            };
+        };
+        request.onerror = (event) => {
+            console.error("Error opening indexDB", event);
+            reject();
+        };
+    });
+}
+
+export async function deleteRowFromIndexDB(tableName: string, id: number | string): Promise<void> {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(INDEXED_DB_NAME);
+        request.onsuccess = (_event) => {
+            const db = request.result;
+            const transaction = db.transaction([tableName], "readwrite");
+            const objectStore = transaction.objectStore(tableName);
+            const deleteRequest = objectStore.delete(id);
+            deleteRequest.onsuccess = (_event) => {
+                resolve();
+            };
+            deleteRequest.onerror = (event) => {
+                console.error("Error deleting save data from indexDB", event);
+                reject();
+            };
+        };
+        request.onerror = (event) => {
+            console.error("Error deleting save data from indexDB", event);
+        };
+    });
+}
+
+export async function getListFromIndexDB<T extends {}>(
+    tableName: string,
+    options: {
+        order?: { field: keyof T; direction: IDBCursorDirection };
+        pagination?: { offset: number; limit: number };
+    } = {},
+): Promise<T[]> {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(INDEXED_DB_NAME);
+        request.onsuccess = (_event) => {
+            const db = request.result;
+            // check if the object store exists
+            if (!db.objectStoreNames.contains(tableName)) {
+                resolve([]);
+                return;
+            }
+            const transaction = db.transaction([tableName], "readwrite");
+            const objectStore = transaction.objectStore(tableName);
+            const getRequest = options.order
+                ? objectStore
+                      .index(options.order.field as string)
+                      .openCursor(null, options.order.direction)
+                : objectStore.openCursor();
+            const results: T[] = [];
+            let counter = 0;
+            const limit = options.pagination?.limit ?? Infinity;
+            const offset = options.pagination?.offset ?? 0;
+            let advanced = false;
+            getRequest.onsuccess = (_event) => {
+                const cursor = getRequest.result;
+                if (cursor) {
+                    if (counter >= offset) {
+                        results.push(cursor.value);
+                        if (results.length >= limit) {
+                            resolve(results);
+                            advanced = true;
+                        }
+                    }
+                    counter++;
+                    cursor.continue();
+                } else {
+                    if (!advanced) {
+                        resolve(results);
+                    }
+                }
+            };
+            getRequest.onerror = (event) => {
+                console.error("Error getting save data from indexDB", event);
+                reject();
+            };
+        };
+        request.onerror = (event) => {
+            console.error("Error opening indexDB", event);
+            reject();
+        };
+    });
+}

package/template-nqtr-react-vite-muijoy/src/lib/utils/save-utility.ts

@@ -0,0 +1,152 @@
+import {
+    deleteRowFromIndexDB,
+    getLastRowFromIndexDB,
+    getListFromIndexDB,
+    getRowFromIndexDB,
+    INDEXED_DB_SAVE_TABLE,
+    putRowIntoIndexDB,
+} from "@/lib/utils/db-utility";
+import type GameSaveData from "@/models/GameSaveData";
+import { canvas, Game } from "@drincs/pixi-vn";
+
+const SAVE_FILE_EXTENSION = "json";
+const REFRESH_SAVE_LOCAL_STORAGE_KEY = "refresh_save";
+
+export function createGameSave(options?: { image?: string; name?: string }): GameSaveData {
+    const { image, name = "" } = options || {};
+    return {
+        saveData: Game.exportGameState(),
+        gameVersion: __APP_VERSION__,
+        date: new Date(),
+        name: name,
+        image: image,
+    };
+}
+
+export async function loadSave(saveData: GameSaveData) {
+    await Game.restoreGameState(saveData.saveData);
+}
+
+export async function saveGameToIndexDB(
+    info: Partial<GameSaveData> & { id?: number } = {},
+    data = createGameSave(),
+): Promise<GameSaveData & { id: number }> {
+    const { image = await canvas.extractImage(), ...rest } = info;
+    const item = {
+        ...data,
+        image: image,
+        ...rest,
+    };
+    if (item.id === undefined) {
+        const lastSave = await getLastRowFromIndexDB<GameSaveData & { id: number }>(
+            INDEXED_DB_SAVE_TABLE,
+        );
+        if (lastSave) {
+            item.id = lastSave.id + 1;
+        } else {
+            item.id = 0;
+        }
+    }
+    await putRowIntoIndexDB(INDEXED_DB_SAVE_TABLE, item);
+    if (item.id) {
+        return item as GameSaveData & { id: number };
+    }
+    return (await getLastSaveFromIndexDB()) as GameSaveData & { id: number };
+}
+
+export async function getSaveFromIndexDB(
+    id: number,
+): Promise<(GameSaveData & { id: number }) | null> {
+    return await getRowFromIndexDB(INDEXED_DB_SAVE_TABLE, id);
+}
+
+export async function getLastSaveFromIndexDB(): Promise<(GameSaveData & { id: number }) | null> {
+    const list = await getListFromIndexDB<GameSaveData & { id: number }>(INDEXED_DB_SAVE_TABLE, {
+        pagination: { limit: 1, offset: 0 },
+        order: { field: "date", direction: "prev" },
+    });
+    const indexedDbSave = list.length > 0 ? list[0] : null;
+
+    const refreshJsonString = localStorage.getItem(REFRESH_SAVE_LOCAL_STORAGE_KEY);
+    if (refreshJsonString) {
+        const refreshSave: GameSaveData & { id: number } = {
+            ...(JSON.parse(refreshJsonString) as GameSaveData),
+            id: -1,
+        };
+        if (!indexedDbSave || new Date(refreshSave.date) > new Date(indexedDbSave.date)) {
+            return refreshSave;
+        }
+    }
+
+    return indexedDbSave;
+}
+
+export async function deleteSaveFromIndexDB(id: number): Promise<void> {
+    return await deleteRowFromIndexDB(INDEXED_DB_SAVE_TABLE, id);
+}
+
+export function downloadGameSave(data: GameSaveData = createGameSave()) {
+    const jsonString = JSON.stringify(data);
+    // download the save data as a JSON file
+    const blob = new Blob([jsonString], { type: "application/json" });
+    // download the file
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = `${__APP_NAME__}-${__APP_VERSION__}-${data.name} ${data.date.toISOString()}.${SAVE_FILE_EXTENSION}`;
+    a.click();
+}
+
+export function loadGameSaveFromFile(afterLoad?: (error?: Error) => void) {
+    // load the save data from a JSON file
+    const input = document.createElement("input");
+    input.type = "file";
+    input.accept = `application/${SAVE_FILE_EXTENSION}`;
+    input.onchange = (e) => {
+        const file = (e.target as HTMLInputElement).files?.[0];
+        if (file) {
+            const reader = new FileReader();
+            reader.onload = (e) => {
+                const jsonString = e.target?.result as string;
+                const data: GameSaveData = JSON.parse(jsonString);
+                // load the save data from the JSON string
+                loadSave(data)
+                    .then(() => {
+                        afterLoad?.();
+                    })
+                    .catch((err) => {
+                        afterLoad?.(err);
+                    });
+            };
+            reader.readAsText(file);
+        }
+    };
+    input.click();
+}
+
+export async function addRefreshSave() {
+    const data = createGameSave();
+    const jsonString = JSON.stringify(data);
+    if (jsonString) {
+        localStorage.setItem(REFRESH_SAVE_LOCAL_STORAGE_KEY, jsonString);
+    }
+}
+
+export async function loadRefreshSave(): Promise<boolean> {
+    const jsonString = localStorage.getItem(REFRESH_SAVE_LOCAL_STORAGE_KEY);
+    if (jsonString) {
+        const data: GameSaveData = JSON.parse(jsonString);
+
+        return loadSave(data)
+            .then(() => {
+                localStorage.removeItem(REFRESH_SAVE_LOCAL_STORAGE_KEY);
+                return true;
+            })
+            .catch(() => {
+                Game.clear();
+                return false;
+            });
+    } else {
+        return false;
+    }
+}

package/template-nqtr-react-vite-muijoy/src/lib/utils/scroll-utils.ts

@@ -0,0 +1,24 @@
+export function isScrollableElement(element: HTMLElement | null): boolean {
+    if (!element) return false;
+
+    const style = window.getComputedStyle(element);
+    const overflowY = style.overflowY;
+
+    return (
+        (overflowY === "auto" || overflowY === "scroll") &&
+        element.scrollHeight > element.clientHeight
+    );
+}
+
+export function hasScrollableParent(target: EventTarget | null): boolean {
+    let el = target as HTMLElement | null;
+
+    while (el) {
+        if (isScrollableElement(el)) {
+            return true;
+        }
+        el = el.parentElement;
+    }
+
+    return false;
+}

package/template-nqtr-react-vite-muijoy/src/lib/utils/ui-utility.ts

@@ -0,0 +1,13 @@
+import type { PixiUIProp } from "@/models/nqtr/ui-elements";
+import TimeSlotsImage from "@/models/TimeSlotsImage";
+import type { OnRunProps } from "@drincs/nqtr";
+
+export async function normalizePixiElement(element: PixiUIProp, props: OnRunProps) {
+    if (typeof element === "function") {
+        element = await element(props);
+    }
+    if (element instanceof TimeSlotsImage) {
+        element = element.src;
+    }
+    return element;
+}

package/template-nqtr-react-vite-muijoy/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+    return twMerge(clsx(inputs));
+}

package/template-nqtr-react-vite-muijoy/src/locales/en.json

@@ -0,0 +1,159 @@
+{
+  "narration": {},
+  "ui": {
+    "allert_error_occurred": "An error occurred, please report it to the developer",
+    "attention": "Attention",
+    "auto_forward_time": "Auto Forward Time",
+    "auto_forward_time_description": "Seconds to wait before auto-advancing. When Text Speed is on, waits for the typewriter to finish first.",
+    "auto_forward_time_restricted": "Auto",
+    "back": "Back",
+    "cancel": "Cancel",
+    "confirm": "Confirm",
+    "continue": "Continue",
+    "continue_refresh_save_tooltip": "Last time you exited without saving. You can continue from where you left off.",
+    "delete": "Delete",
+    "dialogues": "Dialogues",
+    "display": "Display",
+    "enter_fullscreen": "Enter Fullscreen",
+    "example": "Example",
+    "exit": "Exit",
+    "exit_fullscreen": "Exit Fullscreen",
+    "fail_delete": "Delete failed",
+    "fail_load": "Load failed",
+    "fail_save": "Save failed",
+    "fullscreen": "Fullscreen",
+    "fullscreen_description": "Toggle fullscreen mode.",
+    "hide_ui": "Hide UI",
+    "history": "History",
+    "history_hotkey_description": "Open settings directly on the history list.",
+    "load": "Load",
+    "load_from_file": "Load from File",
+    "load_last_save": "Load Last Save",
+    "quick_load_hotkey_description": "Load the latest save slot.",
+    "quick_load_hotkey_alternative_description": "Load the latest save slot with Ctrl+L.",
+    "load_last_save_restricted": "L.Load",
+    "next": "Next",
+    "off": "Off",
+    "primary_color": "Primary Color",
+    "primary_color_description": "Choose the primary color for the theme.",
+    "quick_save": "Quick Save",
+    "quick_save_hotkey_description": "Save the current progress immediately.",
+    "quick_save_hotkey_alternative_description": "Save the current progress with Ctrl+S.",
+    "quick_save_restricted": "Q.Save",
+    "return_main_menu": "Return to Main Menu",
+    "save": "Save",
+    "saving": "Saving…",
+    "save_name": "Name",
+    "you_sure_to_overwrite_save": "You are about to overwrite this save. This action cannot be undone.",
+    "overwrite_save": "Overwrite Save",
+    "save_slot": "File",
+    "save_to_file": "Save to File",
+    "search": "Search",
+    "hotkeys_menu": "Controls",
+    "hotkeys_menu_shortcut_description": "Open settings directly on the controls list.",
+    "hotkeys_menu_no_description": "No description available",
+    "hotkeys_menu_active": "Active",
+    "hotkeys_menu_inactive": "Inactive",
+    "hotkeys_menu_no_results": "No controls found.",
+    "settings": "Settings",
+    "settings_toggle_hotkey_description": "Open or close the settings menu.",
+    "settings_restricted": "Prefs",
+    "about": "About",
+    "name": "Name",
+    "version": "Version",
+    "engine": "Engine",
+    "quick_actions": "Quick Actions",
+    "quick_actions_open_description": "Press Tab to open or close the quick actions wheel.",
+    "quick_actions_click_hint": "Click an action to execute",
+    "skip": "Skip",
+    "skip_hold_description": "Hold Enter to enable skip mode.",
+    "skip_hold_space_description": "Hold Space to enable skip mode.",
+    "skip_release_description": "Release Enter to disable skip mode and continue.",
+    "skip_release_space_description": "Release Space to disable skip mode and continue.",
+    "skip_description": "Automatically advance through already-read dialogues.",
+    "solid_color": "Solid Color",
+    "solid_color_description": "Choose the solid color for the theme. It can be black or white and will be contrasting with the primary color. So if the primary color is dark, the solid color will be white, and a the other way around.",
+    "start": "Start",
+    "quit": "Quit",
+    "quit_confirm": "Are you sure you want to quit the game?",
+    "menu_navigation": "Menu Navigation",
+    "menu_navigation_down_description": "Focus the next menu item.",
+    "menu_navigation_up_description": "Focus the previous menu item.",
+    "menu_navigation_home_description": "Focus the first menu item.",
+    "menu_navigation_end_description": "Focus the last menu item.",
+    "choice_navigation": "Choices",
+    "choice_navigation_description": "Use ↑ / ↓ to select an choice, then Enter to run it.",
+    "success_delete": "Delete successful",
+    "success_load": "Load successful",
+    "success_save": "Save successful",
+    "text_speed": "Text Speed",
+    "text_speed_description": "Choose the speed of the typewriter effect. If is set to 0 ( off ) the text will appear instantly.",
+    "text_size": "Text Size",
+    "text_size_description": "Adjust the font size of the entire interface.",
+    "theme_mode": "Theme Mode",
+    "theme_mode_description": "Choose between light, dark, or system theme mode.",
+    "you_sure_to_delete_save": "Are you sure you want to delete this save file?",
+    "you_sure_to_load_save": "Are you sure you want to load this save file?",
+    "you_sure_to_return_main_menu": "Are you sure you want to return to the main menu? All unsaved progress will be lost.",
+    "download_locale": "Export strings for translation",
+    "sound": "Audio",
+    "master_volume": "Master Volume",
+    "home": "Home",
+    "main": "Main",
+    "menus": "Menus",
+    "bgm_volume": "Music Volume",
+    "sfx_volume": "Sound Effects Volume",
+    "master_volume_description": "Controls the overall audio level for the game. Use this to raise or lower all sounds at once.",
+    "bgm_volume_description": "Sets the volume for background music tracks only.",
+    "sfx_volume_description": "Sets the volume for sound effects such as UI clicks and in-game actions.",
+    "generated_with_engine": "Powered by {{engine}}",
+    "powered_by": "Powered by",
+    "language": "Language",
+    "language_description": "Choose the display language. When the language matches your browser setting, it is marked as \"(system)\".",
+    "system": "System",
+    "offline_title": "No internet connection",
+    "offline_description": "The game is paused until a stable connection is available again.",
+    "offline_checking": "Checking connection…",
+    "offline_hint": "Check your network and try again.",
+    "offline_retry": "Retry now",
+    "morning": "Morning",
+    "afternoon": "Afternoon",
+    "evening": "Evening",
+    "night": "Night",
+    "monday": "Monday",
+    "tuesday": "Tuesday",
+    "wednesday": "Wednesday",
+    "thursday": "Thursday",
+    "friday": "Friday",
+    "saturday": "Saturday",
+    "sunday": "Sunday",
+    "nap": "Nap",
+    "sleep": "Sleep",
+    "allarm_menu_item": "{{hour}} 00",
+    "nap_menu_item": "{{hour}} hours",
+    "wait": "Wait",
+    "quests": "Quests",
+    "completed": "Completed",
+    "failed": "Failed",
+    "memo": "Memo",
+    "map": "Map",
+    "no_active_quests": "No active quests.",
+    "quest_completed_description": "This quest has been completed.",
+    "quest_is_in_development": "That is all for the moment. The quest is in development.",
+    "notify_quest_is_started": "The \"{{quest}}\" quest has started.",
+    "notify_quest_is_updated": "The \"{{quest}}\" quest has been updated.",
+    "bed": "Bed",
+    "order_product": "Order Products",
+    "take_product": "Take Product",
+    "cant_sleep_now": "You can't sleep now",
+    "cant_wait_now": "You can't wait anymore, you should sleep now",
+    "room_hotkey": "Rooms",
+    "activity_hotkey": "Activities",
+    "open_map_hotkey_description": "Open the map.",
+    "open_memo_hotkey_description": "Open or close the memo and quest list.",
+    "wait_hotkey_description": "Wait one hour.",
+    "navigate_room_hotkey_description": "Navigate to room.",
+    "select_run_activity_hotkey_description": "Use ↑ / ↓ to select an activity, then Enter to run it.",
+    "quests_toggle_hotkey_description": "Open the quest list."
+  }
+}

package/template-nqtr-react-vite-muijoy/src/main.tsx

@@ -1,24 +1,24 @@
-import { Assets, canvas, Container, drawCanvasErrorHandler, Game, sound, storage } from "@drincs/pixi-vn";
-import "@drincs/pixi-vn-spine";
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { createRoot } from "react-dom/client";
-import App from "./App";
+import App from "@/App";
 import {
     BGM_CHANNEL_NAME,
     CANVAS_UI_LAYER_NAME,
     HTML_CANVAS_LAYER_NAME,
     HTML_UI_LAYER_NAME,
-    NAVIGATION_ROUTE,
     SFX_CHANNEL_NAME,
-} from "./constans";
-import "./index.css";
-
-// Register service worker
-if ("serviceWorker" in navigator) {
-    window.addEventListener("load", () => {
-        navigator.serviceWorker.register("/service-worker.js").catch(console.error);
-    });
-}
+} from "@/constants";
+import { ChannelSound } from "@/lib/stores/channel-sound-stores";
+import { MasterSound } from "@/lib/stores/master-sound-storage";
+import "@/styles.css";
+import {
+    Assets,
+    canvas,
+    Container,
+    drawCanvasErrorHandler,
+    Game,
+    sound,
+    storage,
+} from "@drincs/pixi-vn";
+import { createRoot } from "react-dom/client";
 
 // Canvas setup with PIXI
 const body = document.body;
@@ -40,6 +40,8 @@ Game.init(body, {
     sound.addChannel(BGM_CHANNEL_NAME, { background: true });
     sound.addChannel(SFX_CHANNEL_NAME);
     sound.defaultChannelAlias = SFX_CHANNEL_NAME;
+    MasterSound.init();
+    ChannelSound.init();
 
     // React setup with ReactDOM
     const root = document.getElementById("root");
@@ -52,28 +54,22 @@ Game.init(body, {
         throw new Error("htmlLayout not found");
     }
     const reactRoot = createRoot(htmlLayout);
-    const queryClient = new QueryClient();
-
-    reactRoot.render(
-        <QueryClientProvider client={queryClient}>
-            <App />
-        </QueryClientProvider>,
-    );
+    reactRoot.render(<App />);
 });
 
 Game.onEnd(async ({ navigate }) => {
-    let isTheEnd = storage.getFlag("is_the_end");
+    const isTheEnd = storage.getFlag("is_the_end");
     if (isTheEnd) {
         Game.clear();
-        navigate("/");
+        navigate({ to: "/" });
     } else {
-        navigate(NAVIGATION_ROUTE);
+        navigate({ to: "/game/navigation" });
     }
 });
 
 Game.addOnError(drawCanvasErrorHandler());
-Game.addOnError((error, { notify, uiTransition }) => {
-    notify && uiTransition && notify(uiTransition("allert_error_occurred"), { variant: "error" });
+Game.addOnError((error, { toast, uiTransition }) => {
+    toast && uiTransition && toast.error(uiTransition("allert_error_occurred"));
     console.error(`Error occurred`, error);
 });
 

package/template-nqtr-react-vite-muijoy/src/models/Character.ts

@@ -1,4 +1,4 @@
-import { CharacterInterface, CharacterStoredClass } from "@drincs/pixi-vn";
+import { type CharacterInterface, CharacterStoredClass } from "@drincs/pixi-vn";
 
 export default class Character extends CharacterStoredClass implements CharacterInterface {
     /**

package/template-nqtr-react-vite-muijoy/src/models/GameSaveData.ts

@@ -1,4 +1,4 @@
-import { GameState } from "@drincs/pixi-vn";
+import type { GameState } from "@drincs/pixi-vn";
 
 export default interface GameSaveData {
     saveData: GameState;

package/template-nqtr-react-vite-muijoy/src/models/TimeSlotsImage.ts

@@ -8,7 +8,9 @@ enum TimeSlotsEnumNumber {
 }
 
 export default class TimeSlotsImage {
-    constructor(data: { morning: string; afternoon: string; evening: string; night: string } | string) {
+    constructor(
+        data: { morning: string; afternoon: string; evening: string; night: string } | string,
+    ) {
         if (typeof data === "string") {
             this.morning = data;
             this.afternoon = data;