imxc 0.5.4 → 0.6.0

package/dist/templates/minimal.js

@@ -0,0 +1,165 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { registerTemplate, APP_TSX, buildImxDts, TSCONFIG, GITIGNORE, cmakeTemplate } from './index.js';
+const APPSTATE_INTERFACE = `interface AppState {
+    count: number;
+    speed: number;
+    onIncrement: () => void;
+}`;
+const APPSTATE_H = `#pragma once
+#include <functional>
+
+struct AppState {
+    int count = 0;
+    float speed = 5.0f;
+    std::function<void()> onIncrement;
+};
+`;
+const MAIN_CPP = `#include <imx/runtime.h>
+#include <imx/renderer.h>
+
+#include <imgui.h>
+#include <imgui_impl_glfw.h>
+#include <imgui_impl_opengl3.h>
+#include <GLFW/glfw3.h>
+
+#include "AppState.h"
+
+struct App {
+    GLFWwindow*      window  = nullptr;
+    ImGuiIO*         io      = nullptr;
+    imx::Runtime runtime;
+    AppState state;
+};
+
+static void render_frame(App& app) {
+    glfwMakeContextCurrent(app.window);
+    if (glfwGetWindowAttrib(app.window, GLFW_ICONIFIED) != 0) return;
+
+    int fb_w = 0, fb_h = 0;
+    glfwGetFramebufferSize(app.window, &fb_w, &fb_h);
+    if (fb_w <= 0 || fb_h <= 0) return;
+
+    ImGui_ImplOpenGL3_NewFrame();
+    ImGui_ImplGlfw_NewFrame();
+    ImGui::NewFrame();
+
+    imx::render_root(app.runtime, app.state);
+
+    ImGui::Render();
+    glViewport(0, 0, fb_w, fb_h);
+    glClearColor(0.12F, 0.12F, 0.15F, 1.0F);
+    glClear(GL_COLOR_BUFFER_BIT);
+    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+
+    if ((app.io->ConfigFlags & ImGuiConfigFlags_ViewportsEnable) != 0) {
+        ImGui::UpdatePlatformWindows();
+        ImGui::RenderPlatformWindowsDefault();
+    }
+
+    glfwMakeContextCurrent(app.window);
+    glfwSwapBuffers(app.window);
+}
+
+static void window_size_callback(GLFWwindow* window, int, int) {
+    auto* app = static_cast<App*>(glfwGetWindowUserPointer(window));
+    if (app) render_frame(*app);
+}
+
+int main() {
+    if (glfwInit() == 0) return 1;
+
+    const char* glsl_version = "#version 150";
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+#ifdef __APPLE__
+    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+#endif
+
+    GLFWwindow* window = glfwCreateWindow(800, 600, "APP_NAME", nullptr, nullptr);
+    if (!window) { glfwTerminate(); return 1; }
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1);
+
+    IMGUI_CHECKVERSION();
+    ImGui::CreateContext();
+    ImGuiIO& io = ImGui::GetIO();
+    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
+    io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
+
+    ImGui::StyleColorsDark();
+    ImGuiStyle& style = ImGui::GetStyle();
+    if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable) {
+        style.WindowRounding = 0.0F;
+        style.Colors[ImGuiCol_WindowBg].w = 1.0F;
+    }
+
+    ImGui_ImplGlfw_InitForOpenGL(window, true);
+    ImGui_ImplOpenGL3_Init(glsl_version);
+
+    App app;
+    app.window = window;
+    app.io = &io;
+    glfwSetWindowUserPointer(window, &app);
+    glfwSetWindowSizeCallback(window, window_size_callback);
+    app.state.onIncrement = [&]() { app.state.count++; };
+
+    while (glfwWindowShouldClose(window) == 0) {
+        if (app.runtime.needs_frame()) {
+            glfwPollEvents();
+        } else {
+            glfwWaitEventsTimeout(0.1);
+        }
+        render_frame(app);
+        app.runtime.frame_rendered(ImGui::IsAnyItemActive());
+    }
+
+    ImGui_ImplOpenGL3_Shutdown();
+    ImGui_ImplGlfw_Shutdown();
+    ImGui::DestroyContext();
+    glfwDestroyWindow(window);
+    glfwTerminate();
+    return 0;
+}
+
+#ifdef _WIN32
+#include <windows.h>
+int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) { return main(); }
+#endif
+`;
+function generate(projectDir, projectName) {
+    const srcDir = path.join(projectDir, 'src');
+    if (fs.existsSync(path.join(srcDir, 'App.tsx'))) {
+        console.error(`Error: ${srcDir}/App.tsx already exists. Aborting.`);
+        process.exit(1);
+    }
+    fs.mkdirSync(srcDir, { recursive: true });
+    const publicDir = path.join(projectDir, 'public');
+    fs.mkdirSync(publicDir, { recursive: true });
+    // Write files
+    fs.writeFileSync(path.join(srcDir, 'main.cpp'), MAIN_CPP.replace('APP_NAME', projectName));
+    fs.writeFileSync(path.join(srcDir, 'AppState.h'), APPSTATE_H);
+    fs.writeFileSync(path.join(srcDir, 'App.tsx'), APP_TSX);
+    fs.writeFileSync(path.join(srcDir, 'imx.d.ts'), buildImxDts(APPSTATE_INTERFACE));
+    fs.writeFileSync(path.join(projectDir, 'tsconfig.json'), TSCONFIG);
+    fs.writeFileSync(path.join(projectDir, 'CMakeLists.txt'), cmakeTemplate(projectName, 'https://github.com/bgocumlu/imx.git'));
+    fs.writeFileSync(path.join(projectDir, '.gitignore'), GITIGNORE);
+    console.log(`imxc: initialized project "${projectName}" with template "minimal"`);
+    console.log('');
+    console.log('  Created:');
+    console.log(`    src/main.cpp          — app shell (GLFW + OpenGL + ImGui)`);
+    console.log(`    src/AppState.h        — C++ state struct (bound to TSX props)`);
+    console.log(`    src/App.tsx           — your root component`);
+    console.log(`    src/imx.d.ts          — type definitions for IDE support`);
+    console.log(`    tsconfig.json         — TypeScript config`);
+    console.log(`    CMakeLists.txt        — build config with FetchContent`);
+    console.log(`    .gitignore            — ignores build/, node_modules/, *.ini`);
+    console.log(`    public/               — static assets (copied to exe directory)`);
+    console.log('');
+    console.log('  Next steps:');
+    console.log(`    cd ${projectName}`);
+    console.log(`    cmake -B build`);
+    console.log(`    cmake --build build`);
+}
+registerTemplate({ name: 'minimal', description: 'Bare ImGui app with struct binding', generate });

package/dist/templates/networking.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/templates/networking.js

@@ -0,0 +1,244 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { registerTemplate, buildImxDts, TSCONFIG, GITIGNORE, cmakeTemplate } from './index.js';
+const APPSTATE_INTERFACE = `interface AppState {
+    url: string;
+    response: string;
+    loading: boolean;
+    onFetch: () => void;
+}`;
+const APPSTATE_H = `#pragma once
+#include <string>
+#include <functional>
+
+struct AppState {
+    std::string url = "http://jsonplaceholder.typicode.com/todos/1";
+    std::string response = "";
+    bool loading = false;
+    std::function<void()> onFetch;
+};
+`;
+const ASYNC_H = `#pragma once
+#include <thread>
+#include <functional>
+#include <imx/runtime.h>
+
+namespace imx {
+
+// Runs \`work\` on a background thread, then calls \`on_done\` with the result.
+// Calls request_frame() so the UI wakes up to display the result.
+// Replace with a thread pool if you need to limit concurrency.
+template<typename T>
+void run_async(Runtime& runtime, std::function<T()> work, std::function<void(T)> on_done) {
+    std::thread([&runtime, work = std::move(work), on_done = std::move(on_done)]() {
+        T result = work();
+        on_done(std::move(result));
+        runtime.request_frame();
+    }).detach();
+}
+
+} // namespace imx
+`;
+const MAIN_CPP = `#include <imx/runtime.h>
+#include <imx/renderer.h>
+
+#include <imgui.h>
+#include <imgui_impl_glfw.h>
+#include <imgui_impl_opengl3.h>
+#include <GLFW/glfw3.h>
+
+#include <thread>
+#include <imx/httplib.h>
+#include "async.h"
+#include "AppState.h"
+
+struct App {
+    GLFWwindow*      window  = nullptr;
+    ImGuiIO*         io      = nullptr;
+    imx::Runtime runtime;
+    AppState state;
+};
+
+static void render_frame(App& app) {
+    glfwMakeContextCurrent(app.window);
+    if (glfwGetWindowAttrib(app.window, GLFW_ICONIFIED) != 0) return;
+
+    int fb_w = 0, fb_h = 0;
+    glfwGetFramebufferSize(app.window, &fb_w, &fb_h);
+    if (fb_w <= 0 || fb_h <= 0) return;
+
+    ImGui_ImplOpenGL3_NewFrame();
+    ImGui_ImplGlfw_NewFrame();
+    ImGui::NewFrame();
+
+    imx::render_root(app.runtime, app.state);
+
+    ImGui::Render();
+    glViewport(0, 0, fb_w, fb_h);
+    glClearColor(0.12F, 0.12F, 0.15F, 1.0F);
+    glClear(GL_COLOR_BUFFER_BIT);
+    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+
+    if ((app.io->ConfigFlags & ImGuiConfigFlags_ViewportsEnable) != 0) {
+        ImGui::UpdatePlatformWindows();
+        ImGui::RenderPlatformWindowsDefault();
+    }
+
+    glfwMakeContextCurrent(app.window);
+    glfwSwapBuffers(app.window);
+}
+
+static void window_size_callback(GLFWwindow* window, int, int) {
+    auto* app = static_cast<App*>(glfwGetWindowUserPointer(window));
+    if (app) render_frame(*app);
+}
+
+int main() {
+    if (glfwInit() == 0) return 1;
+
+    const char* glsl_version = "#version 150";
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+#ifdef __APPLE__
+    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+#endif
+
+    GLFWwindow* window = glfwCreateWindow(800, 600, "APP_NAME", nullptr, nullptr);
+    if (!window) { glfwTerminate(); return 1; }
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1);
+
+    IMGUI_CHECKVERSION();
+    ImGui::CreateContext();
+    ImGuiIO& io = ImGui::GetIO();
+    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
+    io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
+
+    ImGui::StyleColorsDark();
+    ImGuiStyle& style = ImGui::GetStyle();
+    if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable) {
+        style.WindowRounding = 0.0F;
+        style.Colors[ImGuiCol_WindowBg].w = 1.0F;
+    }
+
+    ImGui_ImplGlfw_InitForOpenGL(window, true);
+    ImGui_ImplOpenGL3_Init(glsl_version);
+
+    App app;
+    app.window = window;
+    app.io = &io;
+    glfwSetWindowUserPointer(window, &app);
+    glfwSetWindowSizeCallback(window, window_size_callback);
+
+    // Wire up the HTTP fetch callback
+    app.state.onFetch = [&]() {
+        app.state.loading = true;
+        app.state.response = "";
+        std::string url = app.state.url;
+        imx::run_async<std::string>(
+            app.runtime,
+            [url]() -> std::string {
+                // Parse http://host/path
+                auto scheme_end = url.find("://");
+                if (scheme_end == std::string::npos)
+                    return "Error: invalid URL (must start with http://)";
+                auto host_start = scheme_end + 3;
+                auto path_start = url.find('/', host_start);
+                std::string host = (path_start != std::string::npos)
+                    ? url.substr(0, path_start) : url;
+                std::string path = (path_start != std::string::npos)
+                    ? url.substr(path_start) : "/";
+
+                // For HTTPS: #define CPPHTTPLIB_OPENSSL_SUPPORT and link OpenSSL
+                httplib::Client cli(host);
+                cli.set_connection_timeout(5);
+                cli.set_read_timeout(5);
+                auto res = cli.Get(path);
+                if (res) return res->body;
+                return "Error: request failed";
+            },
+            [&](std::string body) {
+                app.state.response = std::move(body);
+                app.state.loading = false;
+            }
+        );
+    };
+
+    while (glfwWindowShouldClose(window) == 0) {
+        if (app.runtime.needs_frame()) {
+            glfwPollEvents();
+        } else {
+            glfwWaitEventsTimeout(0.1);
+        }
+        render_frame(app);
+        app.runtime.frame_rendered(ImGui::IsAnyItemActive());
+    }
+
+    ImGui_ImplOpenGL3_Shutdown();
+    ImGui_ImplGlfw_Shutdown();
+    ImGui::DestroyContext();
+    glfwDestroyWindow(window);
+    glfwTerminate();
+    return 0;
+}
+
+#ifdef _WIN32
+#include <windows.h>
+int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) { return main(); }
+#endif
+`;
+const APP_TSX = `export default function App(props: AppState) {
+  return (
+    <DockSpace>
+      <Window title="Networking Demo">
+        <Column gap={8}>
+          <Text>HTTP Client Example</Text>
+          <Separator />
+          <TextInput label="URL" value={props.url} />
+          <Button title="Fetch" onPress={props.onFetch} disabled={props.loading} />
+          {props.loading && <Text color={[1, 0.8, 0, 1]}>Loading...</Text>}
+          {props.response !== "" && <Text wrapped={true}>{props.response}</Text>}
+        </Column>
+      </Window>
+    </DockSpace>
+  );
+}
+`;
+function generate(projectDir, projectName) {
+    const srcDir = path.join(projectDir, 'src');
+    if (fs.existsSync(path.join(srcDir, 'App.tsx'))) {
+        console.error(`Error: ${srcDir}/App.tsx already exists. Aborting.`);
+        process.exit(1);
+    }
+    fs.mkdirSync(srcDir, { recursive: true });
+    const publicDir = path.join(projectDir, 'public');
+    fs.mkdirSync(publicDir, { recursive: true });
+    // Write files
+    fs.writeFileSync(path.join(srcDir, 'main.cpp'), MAIN_CPP.replace('APP_NAME', projectName));
+    fs.writeFileSync(path.join(srcDir, 'AppState.h'), APPSTATE_H);
+    fs.writeFileSync(path.join(srcDir, 'async.h'), ASYNC_H);
+    fs.writeFileSync(path.join(srcDir, 'App.tsx'), APP_TSX);
+    fs.writeFileSync(path.join(srcDir, 'imx.d.ts'), buildImxDts(APPSTATE_INTERFACE));
+    fs.writeFileSync(path.join(projectDir, 'tsconfig.json'), TSCONFIG);
+    fs.writeFileSync(path.join(projectDir, 'CMakeLists.txt'), cmakeTemplate(projectName, 'https://github.com/bgocumlu/imx.git'));
+    fs.writeFileSync(path.join(projectDir, '.gitignore'), GITIGNORE);
+    console.log(`imxc: initialized project "${projectName}" with template "networking"`);
+    console.log('');
+    console.log('  Created:');
+    console.log(`    src/main.cpp          — app shell with HTTP fetch callback`);
+    console.log(`    src/AppState.h        — C++ state struct with URL/response fields`);
+    console.log(`    src/async.h           — run_async() helper (std::thread)`);
+    console.log(`    src/App.tsx           — networking demo UI`);
+    console.log(`    src/imx.d.ts          — type definitions for IDE support`);
+    console.log(`    tsconfig.json         — TypeScript config`);
+    console.log(`    CMakeLists.txt        — build config with FetchContent (imx + cpp-httplib)`);
+    console.log(`    .gitignore            — ignores build/, node_modules/, *.ini`);
+    console.log(`    public/               — static assets (copied to exe directory)`);
+    console.log('');
+    console.log('  Next steps:');
+    console.log(`    cd ${projectName}`);
+    console.log(`    cmake -B build`);
+    console.log(`    cmake --build build`);
+}
+registerTemplate({ name: 'networking', description: 'HTTP client with cpp-httplib', generate });

package/dist/templates/persistence.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/templates/persistence.js

@@ -0,0 +1,238 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { registerTemplate, buildImxDts, TSCONFIG, GITIGNORE, cmakeTemplate } from './index.js';
+const APPSTATE_INTERFACE = `interface AppState {
+    name: string;
+    volume: number;
+    darkMode: boolean;
+    onSave: () => void;
+    onLoad: () => void;
+}`;
+const APPSTATE_H = `#pragma once
+#include <string>
+#include <functional>
+#include <imx/json.hpp>
+
+struct AppState {
+    std::string name = "World";
+    float volume = 50.0F;
+    bool darkMode = true;
+    std::function<void()> onSave;
+    std::function<void()> onLoad;
+};
+
+// Only serialize data fields — callbacks are not persisted
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(AppState, name, volume, darkMode)
+`;
+const PERSISTENCE_H = `#pragma once
+#include <fstream>
+#include <string>
+#include <imx/json.hpp>
+
+namespace imx {
+
+// Save state as formatted JSON. Returns true on success.
+// Saves next to the executable by default — change path for platform app data dirs.
+template<typename T>
+bool save_json(const std::string& path, const T& state) {
+    std::ofstream f(path);
+    if (!f) return false;
+    f << nlohmann::json(state).dump(2);
+    return true;
+}
+
+// Load state from JSON file. Returns true on success, leaves state unchanged on failure.
+template<typename T>
+bool load_json(const std::string& path, T& state) {
+    std::ifstream f(path);
+    if (!f) return false;
+    nlohmann::json j = nlohmann::json::parse(f, nullptr, false);
+    if (j.is_discarded()) return false;
+    nlohmann::from_json(j, state);
+    return true;
+}
+
+} // namespace imx
+`;
+const MAIN_CPP = `#include <imx/runtime.h>
+#include <imx/renderer.h>
+
+#include <imgui.h>
+#include <imgui_impl_glfw.h>
+#include <imgui_impl_opengl3.h>
+#include <GLFW/glfw3.h>
+
+#include "persistence.h"
+#include "AppState.h"
+
+struct App {
+    GLFWwindow*      window  = nullptr;
+    ImGuiIO*         io      = nullptr;
+    imx::Runtime runtime;
+    AppState state;
+};
+
+static void render_frame(App& app) {
+    glfwMakeContextCurrent(app.window);
+    if (glfwGetWindowAttrib(app.window, GLFW_ICONIFIED) != 0) return;
+
+    int fb_w = 0, fb_h = 0;
+    glfwGetFramebufferSize(app.window, &fb_w, &fb_h);
+    if (fb_w <= 0 || fb_h <= 0) return;
+
+    ImGui_ImplOpenGL3_NewFrame();
+    ImGui_ImplGlfw_NewFrame();
+    ImGui::NewFrame();
+
+    imx::render_root(app.runtime, app.state);
+
+    ImGui::Render();
+    glViewport(0, 0, fb_w, fb_h);
+    glClearColor(0.12F, 0.12F, 0.15F, 1.0F);
+    glClear(GL_COLOR_BUFFER_BIT);
+    ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+
+    if ((app.io->ConfigFlags & ImGuiConfigFlags_ViewportsEnable) != 0) {
+        ImGui::UpdatePlatformWindows();
+        ImGui::RenderPlatformWindowsDefault();
+    }
+
+    glfwMakeContextCurrent(app.window);
+    glfwSwapBuffers(app.window);
+}
+
+static void window_size_callback(GLFWwindow* window, int, int) {
+    auto* app = static_cast<App*>(glfwGetWindowUserPointer(window));
+    if (app) render_frame(*app);
+}
+
+int main() {
+    if (glfwInit() == 0) return 1;
+
+    const char* glsl_version = "#version 150";
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
+    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+#ifdef __APPLE__
+    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+#endif
+
+    GLFWwindow* window = glfwCreateWindow(800, 600, "APP_NAME", nullptr, nullptr);
+    if (!window) { glfwTerminate(); return 1; }
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1);
+
+    IMGUI_CHECKVERSION();
+    ImGui::CreateContext();
+    ImGuiIO& io = ImGui::GetIO();
+    io.ConfigFlags |= ImGuiConfigFlags_DockingEnable;
+    io.ConfigFlags |= ImGuiConfigFlags_ViewportsEnable;
+
+    ImGui::StyleColorsDark();
+    ImGuiStyle& style = ImGui::GetStyle();
+    if (io.ConfigFlags & ImGuiConfigFlags_ViewportsEnable) {
+        style.WindowRounding = 0.0F;
+        style.Colors[ImGuiCol_WindowBg].w = 1.0F;
+    }
+
+    ImGui_ImplGlfw_InitForOpenGL(window, true);
+    ImGui_ImplOpenGL3_Init(glsl_version);
+
+    App app;
+    app.window = window;
+    app.io = &io;
+    glfwSetWindowUserPointer(window, &app);
+    glfwSetWindowSizeCallback(window, window_size_callback);
+
+    app.state.onSave = [&]() {
+        imx::save_json("state.json", app.state);
+    };
+    app.state.onLoad = [&]() {
+        imx::load_json("state.json", app.state);
+        app.runtime.request_frame();
+    };
+
+    // Auto-load saved state (silently fails if no file exists)
+    imx::load_json("state.json", app.state);
+
+    while (glfwWindowShouldClose(window) == 0) {
+        if (app.runtime.needs_frame()) {
+            glfwPollEvents();
+        } else {
+            glfwWaitEventsTimeout(0.1);
+        }
+        render_frame(app);
+        app.runtime.frame_rendered(ImGui::IsAnyItemActive());
+    }
+
+    ImGui_ImplOpenGL3_Shutdown();
+    ImGui_ImplGlfw_Shutdown();
+    ImGui::DestroyContext();
+    glfwDestroyWindow(window);
+    glfwTerminate();
+    return 0;
+}
+
+#ifdef _WIN32
+#include <windows.h>
+int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) { return main(); }
+#endif
+`;
+const APP_TSX = `export default function App(props: AppState) {
+  return (
+    <DockSpace>
+      <Window title="Persistence Demo">
+        <Column gap={8}>
+          <Text>JSON Save/Load Example</Text>
+          <Separator />
+          <TextInput label="Name" value={props.name} />
+          <SliderFloat label="Volume" value={props.volume} min={0} max={100} />
+          <Checkbox label="Dark Mode" value={props.darkMode} />
+          <Separator />
+          <Row gap={8}>
+            <Button title="Save" onPress={props.onSave} />
+            <Button title="Load" onPress={props.onLoad} />
+          </Row>
+        </Column>
+      </Window>
+    </DockSpace>
+  );
+}
+`;
+function generate(projectDir, projectName) {
+    const srcDir = path.join(projectDir, 'src');
+    if (fs.existsSync(path.join(srcDir, 'App.tsx'))) {
+        console.error(`Error: ${srcDir}/App.tsx already exists. Aborting.`);
+        process.exit(1);
+    }
+    fs.mkdirSync(srcDir, { recursive: true });
+    const publicDir = path.join(projectDir, 'public');
+    fs.mkdirSync(publicDir, { recursive: true });
+    // Write files
+    fs.writeFileSync(path.join(srcDir, 'main.cpp'), MAIN_CPP.replace('APP_NAME', projectName));
+    fs.writeFileSync(path.join(srcDir, 'AppState.h'), APPSTATE_H);
+    fs.writeFileSync(path.join(srcDir, 'persistence.h'), PERSISTENCE_H);
+    fs.writeFileSync(path.join(srcDir, 'App.tsx'), APP_TSX);
+    fs.writeFileSync(path.join(srcDir, 'imx.d.ts'), buildImxDts(APPSTATE_INTERFACE));
+    fs.writeFileSync(path.join(projectDir, 'tsconfig.json'), TSCONFIG);
+    fs.writeFileSync(path.join(projectDir, 'CMakeLists.txt'), cmakeTemplate(projectName, 'https://github.com/bgocumlu/imx.git'));
+    fs.writeFileSync(path.join(projectDir, '.gitignore'), GITIGNORE);
+    console.log(`imxc: initialized project "${projectName}" with template "persistence"`);
+    console.log('');
+    console.log('  Created:');
+    console.log(`    src/main.cpp          — app shell with save/load callbacks`);
+    console.log(`    src/AppState.h        — C++ state struct with nlohmann/json serialization`);
+    console.log(`    src/persistence.h     — save_json/load_json helpers (nlohmann/json)`);
+    console.log(`    src/App.tsx           — your root component`);
+    console.log(`    src/imx.d.ts          — type definitions for IDE support`);
+    console.log(`    tsconfig.json         — TypeScript config`);
+    console.log(`    CMakeLists.txt        — build config with FetchContent (imx + nlohmann/json)`);
+    console.log(`    .gitignore            — ignores build/, node_modules/, *.ini`);
+    console.log(`    public/               — static assets (copied to exe directory)`);
+    console.log('');
+    console.log('  Next steps:');
+    console.log(`    cd ${projectName}`);
+    console.log(`    cmake -B build`);
+    console.log(`    cmake --build build`);
+}
+registerTemplate({ name: 'persistence', description: 'JSON save/load with nlohmann/json', generate });

package/dist/validator.d.ts

@@ -2,6 +2,7 @@ import ts from 'typescript';
 import type { ParsedFile, ParseError } from './parser.js';
 export interface ValidationResult {
     errors: ParseError[];
+    warnings: ParseError[];
     customComponents: Map<string, string>;
     useStateCalls: UseStateInfo[];
 }