imxc 0.5.4 → 0.6.1

package/dist/parser.d.ts

@@ -10,6 +10,7 @@ export interface ParseError {
     line: number;
     col: number;
     message: string;
+    severity?: 'error' | 'warning';
 }
 export declare function parseFile(filePath: string, source: string): ParsedFile;
 export declare function extractImports(sourceFile: ts.SourceFile): Map<string, string>;

package/dist/templates/async.d.ts

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

package/dist/templates/async.js

@@ -0,0 +1,228 @@
+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 {
+    loading: boolean;
+    result: string;
+    onFetchData: () => void;
+}`;
+const APPSTATE_H = `#pragma once
+#include <string>
+#include <functional>
+
+struct AppState {
+    bool loading = false;
+    std::string result = "";
+    std::function<void()> onFetchData;
+};
+`;
+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 <chrono>
+#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);
+
+    app.state.onFetchData = [&]() {
+        app.state.loading = true;
+        app.state.result = "";
+        imx::run_async<std::string>(
+            app.runtime,
+            []() {
+                // Simulate work — replace with real computation
+                std::this_thread::sleep_for(std::chrono::seconds(2));
+                return std::string("Data loaded successfully!");
+            },
+            [&](std::string res) {
+                app.state.result = std::move(res);
+                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="Async Demo">
+        <Column gap={8}>
+          <Text>Background Task Example</Text>
+          <Separator />
+          <Button
+            title="Fetch Data"
+            onPress={props.onFetchData}
+            disabled={props.loading}
+          />
+          {props.loading && <Text color={[1, 0.8, 0, 1]}>Loading...</Text>}
+          {props.result !== "" && <Text color={[0, 1, 0, 1]}>Result: {props.result}</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 "async"`);
+    console.log('');
+    console.log('  Created:');
+    console.log(`    src/main.cpp          — app shell with background task setup`);
+    console.log(`    src/AppState.h        — C++ state struct with loading/result fields`);
+    console.log(`    src/async.h           — run_async<T> helper (std::thread + request_frame)`);
+    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: 'async', description: 'Background tasks with std::thread', generate });

package/dist/templates/custom.d.ts

@@ -0,0 +1,15 @@
+export interface FeatureModule {
+    name: string;
+    description: string;
+    requires?: string[];
+    includes: string[];
+    appStateCppFields: string;
+    appStateCppHeaders: string[];
+    appStateTsFields: string;
+    callbacks: string;
+    tsxWindow: string;
+    extraFiles: Record<string, string>;
+    dataFields?: string[];
+}
+export declare const FEATURES: FeatureModule[];
+export declare function generateCombined(featureNames: string[], projectDir: string, projectName: string): void;