create-pixi-vn 2.0.14 → 2.1.0

package/template-nqtr-react-vite-muijoy-tauri/src/routes/index.tsx

@@ -0,0 +1,6 @@
+import { MainMenu } from "@/components/menus/main-menu";
+import { createFileRoute } from "@tanstack/react-router";
+
+export const Route = createFileRoute("/")({
+    component: MainMenu,
+});

package/template-nqtr-react-vite-muijoy-tauri/src/styles.css

@@ -0,0 +1,155 @@
+@import "tailwindcss";
+@import "tw-animate-css";
+@import "shadcn/tailwind.css";
+@import "tailwind-animations";
+
+@custom-variant dark (&:is(.dark *));
+@plugin "@tailwindcss/typography";
+
+:root {
+  --background: oklch(1 0 0);
+  --foreground: oklch(0.145 0 0);
+  --card: oklch(1 0 0);
+  --card-foreground: oklch(0.145 0 0);
+  --popover: oklch(1 0 0);
+  --popover-foreground: oklch(0.145 0 0);
+  --primary: oklch(0.205 0 0);
+  --primary-foreground: oklch(0.985 0 0);
+  --secondary: oklch(0.97 0 0);
+  --secondary-foreground: oklch(0.205 0 0);
+  --muted: oklch(0.97 0 0);
+  --muted-foreground: oklch(0.556 0 0);
+  --accent: oklch(0.97 0 0);
+  --accent-foreground: oklch(0.205 0 0);
+  --destructive: oklch(0.577 0.245 27.325);
+  --border: oklch(0.922 0 0);
+  --input: oklch(0.922 0 0);
+  --ring: oklch(0.708 0 0);
+  --chart-1: oklch(0.87 0 0);
+  --chart-2: oklch(0.556 0 0);
+  --chart-3: oklch(0.439 0 0);
+  --chart-4: oklch(0.371 0 0);
+  --chart-5: oklch(0.269 0 0);
+  --radius: 0.625rem;
+  --sidebar: oklch(0.985 0 0);
+  --sidebar-foreground: oklch(0.145 0 0);
+  --sidebar-primary: oklch(0.205 0 0);
+  --sidebar-primary-foreground: oklch(0.985 0 0);
+  --sidebar-accent: oklch(0.97 0 0);
+  --sidebar-accent-foreground: oklch(0.205 0 0);
+  --sidebar-border: oklch(0.922 0 0);
+  --sidebar-ring: oklch(0.708 0 0);
+}
+
+html,
+body {
+  background-color: #242424;
+  height: 100%;
+}
+
+body {
+  margin: 0;
+  min-height: 100vh;
+  display: flex;
+  overflow: hidden;
+}
+
+@theme inline {
+  --font-heading: var(--font-sans);
+  --font-sans: "Geist Variable", sans-serif;
+  --color-sidebar-ring: var(--sidebar-ring);
+  --color-sidebar-border: var(--sidebar-border);
+  --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+  --color-sidebar-accent: var(--sidebar-accent);
+  --color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
+  --color-sidebar-primary: var(--sidebar-primary);
+  --color-sidebar-foreground: var(--sidebar-foreground);
+  --color-sidebar: var(--sidebar);
+  --color-chart-5: var(--chart-5);
+  --color-chart-4: var(--chart-4);
+  --color-chart-3: var(--chart-3);
+  --color-chart-2: var(--chart-2);
+  --color-chart-1: var(--chart-1);
+  --color-ring: var(--ring);
+  --color-input: var(--input);
+  --color-border: var(--border);
+  --color-destructive: var(--destructive);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-accent: var(--accent);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-muted: var(--muted);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-secondary: var(--secondary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-primary: var(--primary);
+  --color-popover-foreground: var(--popover-foreground);
+  --color-popover: var(--popover);
+  --color-card-foreground: var(--card-foreground);
+  --color-card: var(--card);
+  --color-foreground: var(--foreground);
+  --color-background: var(--background);
+  --radius-sm: calc(var(--radius) * 0.6);
+  --radius-md: calc(var(--radius) * 0.8);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) * 1.4);
+  --radius-2xl: calc(var(--radius) * 1.8);
+  --radius-3xl: calc(var(--radius) * 2.2);
+  --radius-4xl: calc(var(--radius) * 2.6);
+}
+
+.dark {
+  --background: oklch(0.145 0 0);
+  --foreground: oklch(0.985 0 0);
+  --card: oklch(0.205 0 0);
+  --card-foreground: oklch(0.985 0 0);
+  --popover: oklch(0.205 0 0);
+  --popover-foreground: oklch(0.985 0 0);
+  --primary: oklch(0.922 0 0);
+  --primary-foreground: oklch(0.205 0 0);
+  --secondary: oklch(0.269 0 0);
+  --secondary-foreground: oklch(0.985 0 0);
+  --muted: oklch(0.269 0 0);
+  --muted-foreground: oklch(0.708 0 0);
+  --accent: oklch(0.269 0 0);
+  --accent-foreground: oklch(0.985 0 0);
+  --destructive: oklch(0.704 0.191 22.216);
+  --border: oklch(1 0 0 / 10%);
+  --input: oklch(1 0 0 / 15%);
+  --ring: oklch(0.556 0 0);
+  --chart-1: oklch(0.87 0 0);
+  --chart-2: oklch(0.556 0 0);
+  --chart-3: oklch(0.439 0 0);
+  --chart-4: oklch(0.371 0 0);
+  --chart-5: oklch(0.269 0 0);
+  --sidebar: oklch(0.205 0 0);
+  --sidebar-foreground: oklch(0.985 0 0);
+  --sidebar-primary: oklch(0.488 0.243 264.376);
+  --sidebar-primary-foreground: oklch(0.985 0 0);
+  --sidebar-accent: oklch(0.269 0 0);
+  --sidebar-accent-foreground: oklch(0.985 0 0);
+  --sidebar-border: oklch(1 0 0 / 10%);
+  --sidebar-ring: oklch(0.556 0 0);
+}
+
+@layer base {
+  * {
+    @apply border-border outline-ring/50;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+  html {
+    @apply font-sans;
+  }
+}
+
+@layer components {
+  [data-slot="button"],
+  [data-slot="card"],
+  [data-slot="resizable-handle"],
+  [data-slot="scroll-area"],
+  [data-slot="scroll-area-scrollbar"],
+  [data-slot="toggle"] {
+    pointer-events: auto;
+  }
+}

package/template-nqtr-react-vite-muijoy-tauri/src-tauri/Cargo.toml

@@ -7,6 +7,21 @@ edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+# ── Steam (optional) ─────────────────────────────────────────────────────────
+# To enable Steam support:
+#   1. Set your App ID in steam_appid.txt (root of the repo, use 480 for testing)
+#   2. Change `default = []` to `default = ["steam"]` below, or pass
+#      `--features steam` to cargo / tauri build.
+#   3. On Windows, ship steam_api64.dll next to the executable.
+#   4. On Linux,   ship libsteam_api.so next to the executable.
+#   5. On macOS,   ship libsteam_api.dylib next to the executable.
+#      (The steamworks-sys crate copies the library to the build output
+#       automatically; you only need to include it in the Tauri bundle.)
+# ─────────────────────────────────────────────────────────────────────────────
+[features]
+default = []
+steam = ["dep:steamworks"]
+
 [lib]
 # The `_lib` suffix may seem redundant but it is necessary
 # to make the lib name unique and wouldn't conflict with the bin name.
@@ -20,6 +35,16 @@ tauri-build = { version = "2", features = [] }
 [dependencies]
 tauri = { version = "2", features = [] }
 tauri-plugin-opener = "2"
+tauri-plugin-process = "2"
+tauri-plugin-window-state = "2"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+steamworks = { version = "0.13", optional = true }
+
+[profile.release]
+opt-level = "z"     # max runtime performance
+lto = true          # link-time optimization — removes dead code across crates
+codegen-units = 1   # slower compile, smaller output
+panic = "abort"     # no stack unwinding machinery
+strip = true        # strip symbols from the binary
 

package/template-nqtr-react-vite-muijoy-tauri/src-tauri/build.rs

@@ -1,3 +1,46 @@
+use std::{env, fs, path::PathBuf};
+
 fn main() {
+    if env::var("CARGO_FEATURE_STEAM").is_ok() {
+        copy_steam_lib();
+    }
     tauri_build::build()
 }
+
+// Copies the Steamworks redistributable library from steamworks-sys's OUT_DIR
+// into src-tauri/ so that Tauri's bundler can pick it up as a resource.
+fn copy_steam_lib() {
+    let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
+    let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
+
+    let lib_name = match env::var("CARGO_CFG_TARGET_OS").as_deref() {
+        Ok("windows") => "steam_api64.dll",
+        Ok("macos") => "libsteam_api.dylib",
+        _ => "libsteam_api.so",
+    };
+
+    // OUT_DIR layout: .../target/[profile]/build/[pkg-hash]/out
+    // nth(2) walks up to .../target/[profile]/build/
+    let build_dir = out_dir
+        .ancestors()
+        .nth(2)
+        .expect("unexpected OUT_DIR layout");
+
+    if let Ok(entries) = fs::read_dir(build_dir) {
+        for entry in entries.flatten() {
+            let candidate = entry.path().join("out").join(lib_name);
+            if candidate.exists() {
+                let dest = manifest_dir.join(lib_name);
+                fs::copy(&candidate, &dest)
+                    .unwrap_or_else(|e| panic!("failed to copy {lib_name}: {e}"));
+                println!("cargo:warning=Steam: copied {lib_name} → src-tauri/");
+                return;
+            }
+        }
+    }
+
+    panic!(
+        "Steam: could not find `{lib_name}` in build artifacts. \
+         Ensure `--features steam` is active and the crate compiled successfully."
+    );
+}

package/template-nqtr-react-vite-muijoy-tauri/src-tauri/capabilities/default.json

@@ -5,7 +5,17 @@
   "windows": ["main"],
   "permissions": [
     "core:default",
+    "core:window:allow-close",
+    "core:window:allow-is-fullscreen",
     "core:window:allow-set-fullscreen",
-    "opener:default"
+    "core:window:allow-minimize",
+    "core:window:allow-maximize",
+    "core:window:allow-unminimize",
+    "core:window:allow-set-title",
+    "opener:default",
+    "process:default",
+    "window-state:allow-filename",
+    "window-state:allow-restore-state",
+    "window-state:allow-save-window-state"
   ]
 }

package/template-nqtr-react-vite-muijoy-tauri/src-tauri/src/lib.rs

@@ -1,14 +1,64 @@
-// Learn more about Tauri commands at https://tauri.app/develop/calling-rust/
-#[tauri::command]
-fn greet(name: &str) -> String {
-    format!("Hello, {}! You've been greeted from Rust!", name)
-}
+use tauri::Manager;
+#[cfg(not(mobile))]
+use tauri_plugin_window_state::{AppHandleExt, StateFlags};
+
+// Steam is only compiled on desktop targets when the "steam" feature is on.
+#[cfg(all(feature = "steam", not(target_os = "ios"), not(target_os = "android")))]
+mod steam;
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
-    tauri::Builder::default()
+    #[allow(unused_mut)]
+    let mut builder = tauri::Builder::default()
+        .plugin(tauri_plugin_process::init())
         .plugin(tauri_plugin_opener::init())
-        .invoke_handler(tauri::generate_handler![greet])
+        .on_page_load(on_page_load);
+
+    #[cfg(not(mobile))]
+    let mut builder = builder
+        .plugin(tauri_plugin_window_state::Builder::new().build())
+        .on_window_event(on_window_event);
+
+    // ── Steam ─────────────────────────────────────────────────────────────────
+    // Enabled only when `--features steam` is passed (or `default = ["steam"]`
+    // is set in Cargo.toml). Steam is not supported on iOS / Android.
+    #[cfg(all(feature = "steam", not(target_os = "ios"), not(target_os = "android")))]
+    {
+        builder = builder
+            .manage(steam::SteamClient {
+                client: std::sync::Mutex::new(steam::try_init()),
+            })
+            .invoke_handler(tauri::generate_handler![
+                steam::steam_is_available,
+                steam::steam_get_player_name,
+                steam::steam_get_app_id,
+                steam::steam_unlock_achievement,
+                steam::steam_is_achievement_unlocked,
+                steam::steam_clear_achievement,
+                steam::steam_set_stat_int,
+                steam::steam_get_stat_int,
+                steam::steam_set_stat_float,
+                steam::steam_get_stat_float,
+                steam::steam_store_stats,
+                steam::steam_is_dlc_installed,
+                steam::steam_open_overlay,
+                steam::steam_open_store,
+            ]);
+    }
+
+    builder
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
 }
+
+fn on_page_load(window: &tauri::Webview, _: &tauri::webview::PageLoadPayload<'_>) {
+    #[cfg(not(debug_assertions))]
+    let _ = window.eval("document.addEventListener('contextmenu', e => e.preventDefault())");
+}
+
+#[cfg(not(mobile))]
+fn on_window_event(window: &tauri::Window, event: &tauri::WindowEvent) {
+    if let tauri::WindowEvent::CloseRequested { .. } = event {
+        let _ = window.app_handle().save_window_state(StateFlags::all());
+    }
+}

package/template-nqtr-react-vite-muijoy-tauri/src-tauri/src/steam.rs

@@ -0,0 +1,238 @@
+use std::sync::Mutex;
+use steamworks::{AppId, Client, OverlayToStoreFlag};
+use tauri::State;
+
+pub struct SteamClient {
+    pub client: Mutex<Option<Client>>,
+}
+
+/// Try to initialise Steam. Returns `None` when Steam is not running or the
+/// game is launched outside Steam (e.g. during CI builds).
+///
+/// A background thread is spawned to pump Steam callbacks every 100 ms so
+/// that overlay notifications, stat uploads, and other async operations work.
+pub fn try_init() -> Option<Client> {
+    match Client::init() {
+        Ok(client) => {
+            // Client is Clone + Send + Sync in steamworks 0.13 — safe to move into a thread.
+            let ticker = client.clone();
+            std::thread::spawn(move || loop {
+                ticker.run_callbacks();
+                std::thread::sleep(std::time::Duration::from_millis(100));
+            });
+
+            eprintln!("[Steam] Initialised — App ID {}", client.utils().app_id().0);
+            Some(client)
+        }
+        Err(e) => {
+            eprintln!("[Steam] Not available: {e}");
+            None
+        }
+    }
+}
+
+// ── Commands ──────────────────────────────────────────────────────────────────
+
+/// Returns `true` when Steam was initialised successfully.
+#[tauri::command]
+pub fn steam_is_available(state: State<'_, SteamClient>) -> bool {
+    state.client.lock().map_or(false, |g| g.is_some())
+}
+
+/// Steam display name of the current user (`null` when Steam unavailable).
+#[tauri::command]
+pub fn steam_get_player_name(state: State<'_, SteamClient>) -> Option<String> {
+    state
+        .client
+        .lock()
+        .ok()
+        .and_then(|g| g.as_ref().map(|c| c.friends().name()))
+}
+
+/// Numeric Steam App ID of the running application.
+#[tauri::command]
+pub fn steam_get_app_id(state: State<'_, SteamClient>) -> Option<u32> {
+    state
+        .client
+        .lock()
+        .ok()
+        .and_then(|g| g.as_ref().map(|c| c.utils().app_id().0))
+}
+
+// ── Achievements ──────────────────────────────────────────────────────────────
+
+/// Unlock an achievement and persist it to Steam immediately.
+///
+/// `achievement_id` must match the API Name defined in Steamworks Partner.
+#[tauri::command]
+pub fn steam_unlock_achievement(
+    state: State<'_, SteamClient>,
+    achievement_id: String,
+) -> Result<(), String> {
+    let guard = state.client.lock().map_err(|e| e.to_string())?;
+    let client = guard.as_ref().ok_or("Steam not available")?;
+    let stats = client.user_stats();
+    stats
+        .achievement(&achievement_id)
+        .set()
+        .map_err(|_| format!("Achievement '{}' not found or stats not ready", achievement_id))?;
+    stats
+        .store_stats()
+        .map_err(|_| "Failed to store stats".to_string())
+}
+
+/// Returns `true` if the current user has already unlocked the achievement.
+///
+/// Stats are fetched automatically when Steam initialises. Allow a few seconds
+/// after launch before calling this for the most reliable result.
+#[tauri::command]
+pub fn steam_is_achievement_unlocked(
+    state: State<'_, SteamClient>,
+    achievement_id: String,
+) -> Result<bool, String> {
+    let guard = state.client.lock().map_err(|e| e.to_string())?;
+    let client = guard.as_ref().ok_or("Steam not available")?;
+    client
+        .user_stats()
+        .achievement(&achievement_id)
+        .get()
+        .map_err(|_| format!("Achievement '{}' not found or stats not ready", achievement_id))
+}
+
+/// Reset an achievement (useful during development / QA).
+#[tauri::command]
+pub fn steam_clear_achievement(
+    state: State<'_, SteamClient>,
+    achievement_id: String,
+) -> Result<(), String> {
+    let guard = state.client.lock().map_err(|e| e.to_string())?;
+    let client = guard.as_ref().ok_or("Steam not available")?;
+    let stats = client.user_stats();
+    stats
+        .achievement(&achievement_id)
+        .clear()
+        .map_err(|_| format!("Achievement '{}' not found or stats not ready", achievement_id))?;
+    stats
+        .store_stats()
+        .map_err(|_| "Failed to store stats".to_string())
+}
+
+// ── Stats ─────────────────────────────────────────────────────────────────────
+
+/// Set an integer stat. Call `steam_store_stats` to persist.
+#[tauri::command]
+pub fn steam_set_stat_int(
+    state: State<'_, SteamClient>,
+    name: String,
+    value: i32,
+) -> Result<(), String> {
+    let guard = state.client.lock().map_err(|e| e.to_string())?;
+    let client = guard.as_ref().ok_or("Steam not available")?;
+    client
+        .user_stats()
+        .set_stat_i32(&name, value)
+        .map_err(|_| format!("Failed to set stat '{}'", name))
+}
+
+/// Read an integer stat.
+#[tauri::command]
+pub fn steam_get_stat_int(
+    state: State<'_, SteamClient>,
+    name: String,
+) -> Result<i32, String> {
+    let guard = state.client.lock().map_err(|e| e.to_string())?;
+    let client = guard.as_ref().ok_or("Steam not available")?;
+    client
+        .user_stats()
+        .get_stat_i32(&name)
+        .map_err(|_| format!("Failed to get stat '{}'", name))
+}
+
+/// Set a float stat. Call `steam_store_stats` to persist.
+#[tauri::command]
+pub fn steam_set_stat_float(
+    state: State<'_, SteamClient>,
+    name: String,
+    value: f32,
+) -> Result<(), String> {
+    let guard = state.client.lock().map_err(|e| e.to_string())?;
+    let client = guard.as_ref().ok_or("Steam not available")?;
+    client
+        .user_stats()
+        .set_stat_f32(&name, value)
+        .map_err(|_| format!("Failed to set stat '{}'", name))
+}
+
+/// Read a float stat.
+#[tauri::command]
+pub fn steam_get_stat_float(
+    state: State<'_, SteamClient>,
+    name: String,
+) -> Result<f32, String> {
+    let guard = state.client.lock().map_err(|e| e.to_string())?;
+    let client = guard.as_ref().ok_or("Steam not available")?;
+    client
+        .user_stats()
+        .get_stat_f32(&name)
+        .map_err(|_| format!("Failed to get stat '{}'", name))
+}
+
+/// Commit all pending stat changes to Steam servers.
+/// Achievement commands already call this automatically.
+#[tauri::command]
+pub fn steam_store_stats(state: State<'_, SteamClient>) -> Result<(), String> {
+    let guard = state.client.lock().map_err(|e| e.to_string())?;
+    let client = guard.as_ref().ok_or("Steam not available")?;
+    client
+        .user_stats()
+        .store_stats()
+        .map_err(|_| "Failed to store stats".to_string())
+}
+
+// ── DLC ───────────────────────────────────────────────────────────────────────
+
+/// Returns `true` if the user owns and has the specified DLC installed.
+#[tauri::command]
+pub fn steam_is_dlc_installed(state: State<'_, SteamClient>, app_id: u32) -> bool {
+    state.client.lock().map_or(false, |g| {
+        g.as_ref()
+            .map_or(false, |c| c.apps().is_dlc_installed(AppId(app_id)))
+    })
+}
+
+// ── Overlay ───────────────────────────────────────────────────────────────────
+
+/// Open the Steam overlay to a specific dialog.
+///
+/// Valid `dialog` values:
+///   "achievements", "community", "friends", "players",
+///   "settings", "officialgamegroup", "stats"
+#[tauri::command]
+pub fn steam_open_overlay(state: State<'_, SteamClient>, dialog: String) -> bool {
+    let Ok(guard) = state.client.lock() else {
+        return false;
+    };
+    let Some(client) = guard.as_ref() else {
+        return false;
+    };
+    client.friends().activate_game_overlay(&dialog);
+    true
+}
+
+/// Open the Steam store page for this game (or a specific `app_id`).
+#[tauri::command]
+pub fn steam_open_store(state: State<'_, SteamClient>, app_id: Option<u32>) -> bool {
+    let Ok(guard) = state.client.lock() else {
+        return false;
+    };
+    let Some(client) = guard.as_ref() else {
+        return false;
+    };
+    let target = app_id
+        .map(AppId)
+        .unwrap_or_else(|| client.utils().app_id());
+    client
+        .friends()
+        .activate_game_overlay_to_store(target, OverlayToStoreFlag::None);
+    true
+}

package/template-nqtr-react-vite-muijoy-tauri/src-tauri/tauri.conf.json

@@ -5,7 +5,7 @@
   "identifier": "com.my-app-identifier.app",
   "build": {
     "beforeDevCommand": "npm run dev",
-    "devUrl": "http://localhost:1420",
+    "devUrl": "http://localhost:5173",
     "beforeBuildCommand": "npm run build",
     "frontendDist": "../dist"
   },
@@ -13,10 +13,18 @@
     "withGlobalTauri": true,
     "windows": [
       {
-        "fullscreen": true,
         "title": "my-app-project-name",
-        "width": 800,
-        "height": 600
+        "backgroundColor": "#303030",
+        "theme": "Dark",
+        "width": 1280,
+        "height": 720,
+        "minWidth": 640,
+        "minHeight": 360,
+        "center": true,
+        "fullscreen": false,
+        "resizable": true,
+        "dragDropEnabled": false,
+        "zoomHotkeysEnabled": false
       }
     ],
     "security": {
@@ -32,6 +40,11 @@
       "icons/128x128@2x.png",
       "icons/icon.icns",
       "icons/icon.ico"
-    ]
+    ],
+    "windows": {
+      "nsis": {
+        "installerIcon": "icons/icon.ico"
+      }
+    }
   }
 }

package/template-nqtr-react-vite-muijoy-tauri/tsconfig.app.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2023",
+    "experimentalDecorators": true,
+    "useDefineForClassFields": true,
+    "lib": ["ES2023", "DOM", "DOM.Iterable"],
+    "allowSyntheticDefaultImports": true,
+    "module": "ESNext",
+    "types": ["vite/client"],
+    "skipLibCheck": true,
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "moduleDetection": "force",
+    "resolveJsonModule": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src"]
+}