windowpp 0.1.2 → 0.1.3

package/templates/example/frontend/src/index.tsx

@@ -0,0 +1,24 @@
+/* @refresh reload */
+import './index.css';
+import { render } from 'solid-js/web';
+import { HashRouter, Route } from '@solidjs/router';
+import 'solid-devtools';
+
+import Layout from './Layout';
+import App from './App';
+import Settings from './pages/Settings';
+
+const root = document.getElementById('root');
+
+if (import.meta.env.DEV && !(root instanceof HTMLElement)) {
+  throw new Error(
+    'Root element not found. Did you forget to add it to your index.html? Or maybe the id attribute got misspelled?',
+  );
+}
+
+render(() => (
+  <HashRouter root={Layout}>
+    <Route path="/" component={App} />
+    <Route path="/settings" component={Settings} />
+  </HashRouter>
+), root!);

package/templates/example/frontend/src/pages/About.tsx

@@ -0,0 +1,47 @@
+import { useLocation } from '@solidjs/router';
+import { createSignal, onMount } from 'solid-js';
+
+export default function About() {
+  const location = useLocation();
+  const [href, setHref] = createSignal('');
+
+  onMount(() => {
+    setHref(window.location.href);
+  });
+
+  return (
+    <div class="p-10 max-w-2xl mx-auto text-zinc-100">
+      <h1 class="text-3xl font-bold mb-3">About — Routing Test</h1>
+      <p class="mb-4 text-zinc-400">
+        This page demonstrates <strong class="text-white">hash-based client-side routing</strong> with{' '}
+        <code class="bg-zinc-800 px-1 rounded text-blue-300">@solidjs/router</code>.
+      </p>
+
+      <div class="rounded-lg bg-zinc-900 border border-zinc-700 p-4 font-mono text-sm space-y-1">
+        <div>
+          <span class="text-zinc-500">pathname: </span>
+          <span class="text-green-400">{location.pathname}</span>
+        </div>
+        <div>
+          <span class="text-zinc-500">search: </span>
+          <span class="text-yellow-400">{location.search || '(none)'}</span>
+        </div>
+        <div>
+          <span class="text-zinc-500">hash: </span>
+          <span class="text-blue-400">{location.hash || '(none)'}</span>
+        </div>
+        <div>
+          <span class="text-zinc-500">href: </span>
+          <span class="text-zinc-300 break-all">{href()}</span>
+        </div>
+      </div>
+
+      <p class="mt-5 text-sm text-zinc-500">
+        Hash routing works out-of-the-box with embedded binary assets — the
+        scheme handler returns <code class="bg-zinc-800 px-1 rounded">index.html</code> for
+        any path, and the <code class="bg-zinc-800 px-1 rounded">#fragment</code> is
+        resolved entirely in the browser, never sent to the server.
+      </p>
+    </div>
+  );
+}

package/templates/example/frontend/src/pages/Settings.tsx

@@ -0,0 +1,37 @@
+import { useNavigate } from '@solidjs/router';
+
+export default function Settings() {
+  const navigate = useNavigate();
+
+  return (
+    <div class="min-h-screen bg-[radial-gradient(circle_at_top,#f8fafc,#e2e8f0_40%,#cbd5e1)] px-6 py-8 text-slate-900">
+      <div class="mx-auto max-w-6xl">
+
+        {/* Header Card */}
+        <div class="mb-8 rounded-4xl border border-white/70 bg-white/80 p-8 shadow-2xl shadow-slate-400/20 backdrop-blur">
+          <div class="flex items-center justify-between">
+            <div>
+              <p class="mb-2 text-sm font-semibold uppercase tracking-[0.3em] text-slate-500">WindowPP Playground</p>
+              <h1 class="text-4xl font-bold tracking-tight text-slate-900">Settings</h1>
+            </div>
+            <button
+              class="flex items-center gap-1.5 rounded-2xl border border-slate-200 bg-slate-50 px-4 py-3 text-sm text-slate-600 hover:bg-slate-100 transition-colors select-none"
+              onClick={() => navigate('/')}
+            >
+              <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4 text-slate-500" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                <path d="M19 12H5M12 5l-7 7 7 7"/>
+              </svg>
+              <span class="font-semibold text-slate-800">Back to App</span>
+            </button>
+          </div>
+        </div>
+
+        {/* Placeholder content */}
+        <div class="rounded-4xl border border-white/70 bg-white/80 p-8 shadow-2xl shadow-slate-400/20 backdrop-blur text-slate-500 text-sm">
+          Settings content goes here.
+        </div>
+
+      </div>
+    </div>
+  );
+}

package/templates/example/frontend/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    // General
+    "jsx": "preserve",
+    "jsxImportSource": "solid-js",
+    "target": "ESNext",
+
+    // Modules
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "noEmit": true,
+
+    // Type Checking & Safety
+    "strict": true,
+    "types": ["vite/client"]
+  }
+}

package/templates/example/frontend/vite.config.ts

@@ -0,0 +1,27 @@
+import { resolve } from 'node:path';
+import tailwindcss from '@tailwindcss/vite';
+import { defineConfig } from 'vite';
+import solidPlugin from 'vite-plugin-solid';
+
+const REPO_ROOT = '{{REPO_ROOT}}';
+
+export default defineConfig({
+  plugins: [solidPlugin(), tailwindcss()],
+  base: './',
+  resolve: {
+    alias: {
+      // '@wpp/Foo/bar' resolves to <framework>/src/Foo/bar
+      // Used by templates that import bridge APIs: @wpp/AppData/API/AppData, etc.
+      '@wpp': resolve(REPO_ROOT, 'src'),
+    },
+  },
+  server: {
+    port: 3000,
+    fs: {
+      allow: [REPO_ROOT],
+    },
+  },
+  build: {
+    target: 'esnext',
+  },
+});

package/templates/example/main.cpp

@@ -0,0 +1,224 @@
+// ============================================================================
+//  main.cpp — WindowPP WebView Example
+//
+//  Build modes
+//  ───────────
+//  Release (cmake --build build --config Release):
+//    Frontend is compiled into the binary via embedded_assets.cpp.
+//    The app serves assets from the "app" custom URI scheme — no server needed.
+//
+//  Dev (set env var WPP_DEV_URL before launching):
+//    WPP_DEV_URL=http://localhost:3000 ./{{CMAKE_TARGET}}
+//    The app loads from the Vite dev server instead; hot-reload works normally.
+// ============================================================================
+
+#include <windowpp/windowpp.h>
+#include "AppData/appdata_bridge.h"
+#include "AppData/appdata_manager.h"
+#include "FileSystem/filesystem_bridge.h"
+#include "Input/input_bridge.h"
+#include "platform/platform_bridge.h"
+#include <cstdlib>   // std::getenv
+#include <memory>
+#include <vector>
+
+#ifdef WPP_EMBEDDED_ASSETS
+#include "embedded_assets.h"
+#endif
+
+int main() {
+    wpp::AppConfig app_config;
+    app_config.name = "WindowPP Dev";
+    app_config.quit_on_last_close = true;
+    app_config.tray_enabled = true;
+
+    wpp::AppDataManager app_data(app_config.name);
+
+    auto app = wpp::create_app(app_config);
+
+    wpp::WindowConfig main_win;
+    main_win.id = "main";
+    main_win.title = "WindowPP - Dev View";
+    main_win.width = 1280;
+    main_win.height = 800;
+    main_win.center = true;
+    main_win.frameless = true;
+    main_win.transparent = true;
+    main_win.background = {0, 0, 0, 0};
+
+    main_win.webview.enabled = true;
+    main_win.file_drop = true;
+    main_win.scrollbars = false;
+
+    // Keep all WebView profile data (cookies, cache, localStorage) in the
+    // OS-standard app data directory rather than next to the exe.
+    main_win.webview.user_data_dir = app_data.path("WebView");
+
+    wpp::Window* win = nullptr;
+    auto app_data_bridge = std::make_shared<wpp::appdata::AppDataBridge>(
+        [&win](const std::string& js) {
+            if (win && win->webview()) {
+                win->webview()->execute_script(js);
+            }
+        },
+        app_config.name);
+    auto filesystem_bridge = std::make_shared<wpp::fs::FsBridge>(
+        [&win](const std::string& js) {
+            if (win && win->webview()) {
+                win->webview()->execute_script(js);
+            }
+        },
+        [app_ptr = app.get()](std::function<void()> fn) {
+            app_ptr->dispatch(std::move(fn));
+        },
+        app_data.path("FileIndex"));
+    auto input_bridge = std::make_shared<wpp::input::InputBridge>(
+        [&win](const std::string& js) {
+            if (win && win->webview()) {
+                win->webview()->execute_script(js);
+            }
+        },
+        [app_ptr = app.get()](std::function<void()> fn) {
+            app_ptr->dispatch(std::move(fn));
+        },
+        main_win.id);
+    auto platform_bridge = std::make_shared<wpp::platform_api::PlatformBridge>(
+        [&win](const std::string& js) {
+            if (win && win->webview()) {
+                win->webview()->execute_script(js);
+            }
+        },
+        [app_ptr = app.get()](std::function<void()> fn) {
+            app_ptr->dispatch(std::move(fn));
+        },
+        *app,
+        app_config,
+        main_win.id);
+
+    main_win.on_created = [platform_bridge, window_id = main_win.id]() {
+        platform_bridge->emit_window_event("created", window_id);
+    };
+    main_win.on_shown = [platform_bridge, window_id = main_win.id]() {
+        platform_bridge->emit_window_event("shown", window_id);
+    };
+    main_win.on_hidden = [platform_bridge, window_id = main_win.id]() {
+        platform_bridge->emit_window_event("hidden", window_id);
+    };
+    main_win.on_resize = [platform_bridge, window_id = main_win.id](wpp::ResizeEvent event) {
+        platform_bridge->emit_resize_event(window_id, event);
+    };
+    main_win.on_move = [platform_bridge, window_id = main_win.id](wpp::MoveEvent event) {
+        platform_bridge->emit_move_event(window_id, event);
+    };
+    main_win.on_closed = [platform_bridge, window_id = main_win.id]() {
+        platform_bridge->emit_window_event("closed", window_id);
+    };
+
+    main_win.webview.on_message = [app_data_bridge, filesystem_bridge, input_bridge, platform_bridge](const std::string& raw) {
+        app_data_bridge->dispatch(raw);
+        filesystem_bridge->dispatch(raw);
+        input_bridge->dispatch(raw);
+        platform_bridge->dispatch(raw);
+    };
+
+    // Decide where to load the UI from.
+    const char* dev_url = std::getenv("WPP_DEV_URL");
+    if (dev_url && *dev_url) {
+        // Developer override — point at a running Vite server (or any URL).
+        main_win.webview.initial_url = dev_url;
+    } else {
+#ifdef WPP_EMBEDDED_ASSETS
+        // Production: serve embedded Vite build from the "app://" custom scheme.
+        main_win.webview.custom_scheme = "app";
+        main_win.webview.scheme_handler =
+            [](const std::string& path) -> wpp::SchemeResponse {
+                const EmbeddedAsset* asset = find_asset(path);
+                if (!asset) {
+                    // SPA fallback: unknown paths get index.html so that
+                    // client-side routers (Solid Router, TanStack Router, etc.)
+                    // can handle the route in JavaScript.
+                    asset = find_asset("/index.html");
+                }
+                if (asset) {
+                    return wpp::SchemeResponse{
+                        std::vector<uint8_t>(asset->data, asset->data + asset->size),
+                        asset->content_type,
+                        200
+                    };
+                }
+                std::string body = "404 Not Found";
+                return wpp::SchemeResponse{
+                    std::vector<uint8_t>(body.begin(), body.end()),
+                    "text/plain",
+                    404
+                };
+            };
+        main_win.webview.initial_url = "app://localhost/index.html";
+#else
+        // Fallback when no embedded assets were compiled in.
+        main_win.webview.initial_url = "http://localhost:3000";
+#endif
+    }
+
+    win = app->create_window(main_win);
+
+    if (win && win->webview()) {
+        win->webview()->execute_script("window.__wpp_appdata_ready = true;");
+    }
+
+    // Allow the frontend to open additional windows at specific hash routes.
+    // The URL is computed on the JS side:
+    //   dev:  http://localhost:3000/#/route
+    //   prod: app://localhost/index.html#/route
+    static int child_counter = 0;
+    platform_bridge->set_create_window_fn(
+        [&app, webview_dir = app_data.path("WebView")](
+            const std::string& url,
+            const std::string& title,
+            int width, int height)
+        {
+            wpp::WindowConfig child;
+            child.id          = "child_" + std::to_string(++child_counter);
+            child.title       = title;
+            child.width       = width;
+            child.height      = height;
+            child.center      = true;
+            child.frameless   = true;
+            child.transparent = true;
+            child.background  = {0, 0, 0, 0};
+            child.webview.enabled      = true;
+            child.webview.user_data_dir = webview_dir;
+            child.webview.initial_url   = url;
+
+            // In embedded-assets mode, the child window must also register the
+            // custom "app://" scheme so it can serve the same SPA assets.
+#ifdef WPP_EMBEDDED_ASSETS
+            const char* dev_env = std::getenv("WPP_DEV_URL");
+            if (!dev_env || !*dev_env) {
+                child.webview.custom_scheme = "app";
+                child.webview.scheme_handler =
+                    [](const std::string& path) -> wpp::SchemeResponse {
+                        const EmbeddedAsset* asset = find_asset(path);
+                        if (!asset) asset = find_asset("/index.html");
+                        if (asset) {
+                            return wpp::SchemeResponse{
+                                std::vector<uint8_t>(asset->data, asset->data + asset->size),
+                                asset->content_type,
+                                200
+                            };
+                        }
+                        std::string body = "404 Not Found";
+                        return wpp::SchemeResponse{
+                            std::vector<uint8_t>(body.begin(), body.end()),
+                            "text/plain", 404
+                        };
+                    };
+            }
+#endif
+            app->create_window(child);
+        });
+
+    app->run();
+
+    return 0;
+}

package/templates/example/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "{{APP_NAME}}",
+  "version": "0.1.0",
+  "description": "{{APP_TITLE}} — a WindowPP app",
+  "cmakeTarget": "{{CMAKE_TARGET}}",
+  "scripts": {
+    "dev": "windowpp dev",
+    "dev:clean": "windowpp dev --clean",
+    "build": "windowpp build",
+    "build:clean": "windowpp build --clean"
+  }
+}

package/templates/solid/CMakeLists.txt

@@ -50,7 +50,10 @@ add_custom_target({{CMAKE_TARGET}}_frontend_assets ALL
 )
 
 add_executable({{CMAKE_TARGET}} main.cpp ${EMBEDDED_ASSETS_CPP})
-target_include_directories({{CMAKE_TARGET}} PRIVATE ${GENERATED_DIR})
+target_include_directories({{CMAKE_TARGET}} PRIVATE
+    ${GENERATED_DIR}
+    "${WPP_FRAMEWORK_DIR}/src"   # bridge headers: AppData/, FileSystem/, Input/, platform/
+)
 target_compile_definitions({{CMAKE_TARGET}} PRIVATE WPP_EMBEDDED_ASSETS)
 target_link_libraries({{CMAKE_TARGET}} PRIVATE windowpp windowpp_deps nlohmann_json::nlohmann_json)
 add_dependencies({{CMAKE_TARGET}} {{CMAKE_TARGET}}_frontend_assets)

package/templates/solid/frontend/vite.config.ts

@@ -10,7 +10,9 @@ export default defineConfig({
   base: './',
   resolve: {
     alias: {
-      '@wpp': resolve(REPO_ROOT, 'src/platform/API'),
+      // '@wpp/Foo/bar' resolves to <framework>/src/Foo/bar
+      // Used by templates that import bridge APIs: @wpp/AppData/API/AppData, etc.
+      '@wpp': resolve(REPO_ROOT, 'src'),
     },
   },
   server: {