@flare-desktop/cli 0.1.1 → 0.1.3

package/src/templates/core.js

@@ -0,0 +1,278 @@
+const protocol = 'flare';
+const defaultHost = 'localhost';
+
+const coreCommands = new Map();
+const eventListeners = new Map();
+const channels = new Map();
+
+let listenerSequence = 0;
+let channelSequence = 0;
+
+function resolveBridge() {
+    const bridge = globalThis.__FLARE_BRIDGE__;
+    if (!bridge) {
+        throw new Error('flare: the ipc bridge is not available in this context');
+    }
+    return bridge;
+}
+
+function normalizeCallback(callback) {
+    if (callback === undefined || callback === null) {
+        return undefined;
+    }
+    if (typeof callback === 'function') {
+        return callback;
+    }
+    throw new TypeError('flare: callback must be a function');
+}
+
+export function isFlare() {
+    return typeof globalThis.__FLARE_BRIDGE__ !== 'undefined';
+}
+
+export function metadata() {
+    const bridge = globalThis.__FLARE_BRIDGE__;
+    return Object.freeze({
+        protocol,
+        host: (bridge && bridge.host) || defaultHost,
+        version: (bridge && bridge.version) || '0.0.0'
+    });
+}
+
+export async function invoke(command, payload = {}, options = {}) {
+    if (typeof command !== 'string' || command.length === 0) {
+        throw new TypeError('flare: command must be a non empty string');
+    }
+    const bridge = resolveBridge();
+    const request = {
+        id: options.id || `${Date.now().toString(36)}-${(listenerSequence += 1).toString(36)}`,
+        command,
+        payload: payload === undefined ? {} : payload,
+        window: options.window || '',
+        webview: options.webview || ''
+    };
+    const response = await bridge.invoke(request);
+    if (response === undefined || response === null) {
+        throw new Error(`flare: command '${command}' returned no response`);
+    }
+    if (response.successful === false) {
+        const error = response.error || {};
+        const failure = new Error(error.message || `flare: command '${command}' failed`);
+        failure.code = error.code || 'command-failed';
+        failure.details = error.details;
+        throw failure;
+    }
+    return response.result;
+}
+
+export async function listen(event, handler, options = {}) {
+    if (typeof event !== 'string' || event.length === 0) {
+        throw new TypeError('flare: event name must be a non empty string');
+    }
+    const callback = normalizeCallback(handler);
+    listenerSequence += 1;
+    const id = listenerSequence;
+    const window = options.window || '';
+    if (!eventListeners.has(event)) {
+        eventListeners.set(event, new Map());
+    }
+    eventListeners.get(event).set(id, { callback, window, once: false });
+    const bridge = resolveBridge();
+    if (typeof bridge.attachListener === 'function') {
+        bridge.attachListener(event, id, callback);
+    }
+    try {
+        await bridge.listen({ event, id, window });
+    } catch (error) {
+        eventListeners.get(event)?.delete(id);
+        await bridge.unlisten?.({ event, id });
+        throw error;
+    }
+    return () => unlisten(event, id);
+}
+
+export async function once(event, handler, options = {}) {
+    const remove = await listen(
+        event,
+        (payload) => {
+            remove();
+            if (typeof handler === 'function') {
+                handler(payload);
+            }
+        },
+        options
+    );
+    return remove;
+}
+
+export async function unlisten(event, id) {
+    const entries = eventListeners.get(event);
+    if (entries) {
+        entries.delete(id);
+        if (entries.size === 0) {
+            eventListeners.delete(event);
+        }
+    }
+    const bridge = globalThis.__FLARE_BRIDGE__;
+    if (bridge && typeof bridge.unlisten === 'function') {
+        await bridge.unlisten({ event, id });
+    }
+}
+
+export async function emit(event, payload = {}) {
+    const bridge = resolveBridge();
+    await bridge.emit({ event, payload });
+}
+
+export function dispatch(event, payload = {}) {
+    const entries = eventListeners.get(event);
+    if (!entries) {
+        return 0;
+    }
+    const pending = [];
+    for (const entry of entries.values()) {
+        pending.push(entry);
+    }
+    for (const entry of pending) {
+        if (entry.once) {
+            entries.delete(entry);
+        }
+        try {
+            entry.callback(payload);
+        } catch (error) {
+            console.error(`flare: listener for '${event}' failed`, error);
+        }
+    }
+    return pending.length;
+}
+
+export function createChannel(onMessage) {
+    channelSequence += 1;
+    const id = channelSequence;
+    const name = `channel-${id}`;
+    channels.set(id, { onMessage, closed: false });
+    return {
+        identifier: id,
+        name,
+        async send(payload = {}) {
+            const bridge = resolveBridge();
+            await bridge.channel({ id, payload });
+        },
+        deliver(message) {
+            if (onMessage) {
+                onMessage(message);
+            }
+            if (message && message.state === 'closed') {
+                channels.delete(id);
+            }
+        },
+        close() {
+            channels.delete(id);
+        }
+    };
+}
+
+export function currentWindow() {
+    const label = (globalThis.__FLARE_BRIDGE__ && globalThis.__FLARE_BRIDGE__.window) || 'main';
+    return {
+        label,
+        async close() {
+            return invoke('flare:window:close', { label });
+        },
+        async setTitle(title) {
+            return invoke('flare:window:set-title', { label, title });
+        },
+        async show() {
+            return invoke('flare:window:show', { label });
+        },
+        async hide() {
+            return invoke('flare:window:hide', { label });
+        }
+    };
+}
+
+export const app = Object.freeze({
+    version: () => invoke('flare:app:version'),
+    describe: () => invoke('flare:app:describe'),
+    config: () => invoke('flare:app:config'),
+    platform: () => invoke('flare:app:platform'),
+    exit: () => invoke('flare:app:exit')
+});
+
+export const window = Object.freeze({
+    list: () => invoke('flare:window:list'),
+    emit: (event, payload = {}) => invoke('flare:window:emit', { event, payload })
+});
+
+export const plugins = Object.freeze({
+    list: () => invoke('flare:plugin:list')
+});
+
+export const menu = Object.freeze({
+    describe: () => invoke('flare:menu:describe'),
+    set: (items) => invoke('flare:menu:set', { items }),
+    dispatch: (id) => invoke('flare:menu:dispatch', { id }),
+    onCommand: (handler) => listen('flare:menu:command', (payload) => handler(payload.id, payload))
+});
+
+export const commands = Object.freeze({
+    register(name, handler) {
+        if (typeof name !== 'string' || typeof handler !== 'function') {
+            throw new TypeError('flare: register expects a name and a handler');
+        }
+        coreCommands.set(name, handler);
+    },
+    unregister(name) {
+        return coreCommands.delete(name);
+    },
+    has(name) {
+        return coreCommands.has(name);
+    },
+    names() {
+        return Array.from(coreCommands.keys());
+    }
+});
+
+export const log = Object.freeze({
+    trace: (message) => emit('flare:log:trace', { message }),
+    debug: (message) => emit('flare:log:debug', { message }),
+    info: (message) => emit('flare:log:info', { message }),
+    warn: (message) => emit('flare:log:warn', { message }),
+    error: (message) => emit('flare:log:error', { message })
+});
+
+export const path = Object.freeze({
+    resolve: (name) => invoke('flare:path:resolve', { name }),
+    all: () => invoke('flare:path:all')
+});
+
+export const tray = Object.freeze({
+    describe: () => invoke('flare:tray:describe'),
+    setIcon: (icon) => invoke('flare:tray:set-icon', { icon }),
+    setTooltip: (tooltip) => invoke('flare:tray:set-tooltip', { tooltip }),
+    setTitle: (title) => invoke('flare:tray:set-title', { title }),
+    setVisible: (visible) => invoke('flare:tray:set-visible', { visible }),
+    setMenu: (items) => invoke('flare:tray:set-menu', { items }),
+    dispatch: (id) => invoke('flare:tray:dispatch', { id })
+});
+
+export default {
+    app,
+    commands,
+    createChannel,
+    currentWindow,
+    dispatch,
+    emit,
+    invoke,
+    isFlare,
+    listen,
+    log,
+    menu,
+    metadata,
+    once,
+    path,
+    plugins,
+    tray,
+    unlisten,
+    window
+};

package/src/templates/project.js

@@ -7,7 +7,7 @@ export function embeddedIdentifier(name) {
     .join("");
 }
 
-export function configTemplate({ name, identifier, version }) {
+export function configTemplate({ name, identifier, version, template = "javascript" }) {
   return {
     $schema: SCHEMA_URL,
     package: { productName: name, version },
@@ -18,11 +18,11 @@ export function configTemplate({ name, identifier, version }) {
       version
     },
     build: {
-      frontendDist: "frontend",
-      devUrl: "",
-      beforeDevCommand: "",
+      frontendDist: template === "typescript" ? "dist" : "frontend",
+      devUrl: template === "typescript" ? "http://127.0.0.1:5173" : "",
+      beforeDevCommand: template === "typescript" ? "npm run frontend:dev" : "",
       afterDevCommand: "",
-      beforeBuildCommand: "",
+      beforeBuildCommand: template === "typescript" ? "npm run frontend:build" : "",
       afterBuildCommand: ""
     },
     bundle: {
@@ -51,7 +51,7 @@ export function configTemplate({ name, identifier, version }) {
   };
 }
 
-export function packageJsonTemplate({ name, version, cliVersion }) {
+export function packageJsonTemplate({ name, version, cliVersion, template = "javascript" }) {
   return {
     name,
     version,
@@ -61,15 +61,17 @@ export function packageJsonTemplate({ name, version, cliVersion }) {
       dev: "flare dev",
       build: "flare build",
       bundle: "flare bundle",
-      icon: "flare icon icons/icon.png"
+      icon: "flare icon icons/icon.png",
+      ...(template === "typescript" ? { "frontend:dev": "vite --host 127.0.0.1", "frontend:build": "tsc --noEmit && vite build" } : {})
     },
     devDependencies: {
-      "@flare-desktop/cli": `^${cliVersion}`
+      "@flare-desktop/cli": `^${cliVersion}`,
+      ...(template === "typescript" ? { typescript: "^5.9.3", vite: "^6.4.5" } : {})
     }
   };
 }
 
-export function cmakeTemplate({ name, version, coreVersion }) {
+export function cmakeTemplate({ name, version, coreVersion, sdkMode = "source" }) {
   return `cmake_minimum_required(VERSION 3.24)
 
 project(${name} VERSION ${version} LANGUAGES CXX)
@@ -77,17 +79,48 @@ project(${name} VERSION ${version} LANGUAGES CXX)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
-include(FetchContent)
+if(WIN32 AND NOT DEFINED FLARE_NATIVE_WEBVIEW)
+    set(FLARE_NATIVE_WEBVIEW ON CACHE BOOL "Use the Windows system webview")
+endif()
+
+${sdkMode === "prebuilt" ? `add_subdirectory("\${CMAKE_CURRENT_SOURCE_DIR}/vendor/flare" "\${CMAKE_CURRENT_BINARY_DIR}/flare-sdk")` : `include(FetchContent)
 
 FetchContent_Declare(
     flare
     GIT_REPOSITORY https://github.com/flare-desktop/flare.git
     GIT_TAG v${coreVersion}
     GIT_SHALLOW TRUE)
-FetchContent_MakeAvailable(flare)
+FetchContent_MakeAvailable(flare)`}
 
 add_executable(${name} source/main.cpp)
 target_link_libraries(${name} PRIVATE flare::core flare::assets)
+if(MSVC)
+    target_compile_options(${name} PRIVATE /utf-8)
+endif()
+
+find_program(FLARE_NODE_EXECUTABLE node REQUIRED)
+set(FLARE_CONFIG_FILE "flare.config.json" CACHE STRING "Source application configuration")
+set(FLARE_CONFIG_ENVIRONMENT "production" CACHE STRING "Build configuration layer")
+get_filename_component(FLARE_CONFIG_ABSOLUTE "\${FLARE_CONFIG_FILE}" ABSOLUTE BASE_DIR "\${CMAKE_CURRENT_SOURCE_DIR}")
+get_filename_component(FLARE_CONFIG_DIRECTORY "\${FLARE_CONFIG_ABSOLUTE}" DIRECTORY)
+get_filename_component(FLARE_CONFIG_NAME "\${FLARE_CONFIG_ABSOLUTE}" NAME_WE)
+file(GLOB FLARE_CONFIG_LAYERS CONFIGURE_DEPENDS "\${FLARE_CONFIG_DIRECTORY}/\${FLARE_CONFIG_NAME}*.json")
+set(FLARE_CONFIG_GENERATOR "\${CMAKE_CURRENT_SOURCE_DIR}/node_modules/@flare-desktop/cli/src/lib/embed-config-cli.js")
+set(FLARE_CONFIG_IMPLEMENTATION "\${CMAKE_CURRENT_SOURCE_DIR}/node_modules/@flare-desktop/cli/src/lib/embedded-config.js")
+set(FLARE_CONFIG_LOADER "\${CMAKE_CURRENT_SOURCE_DIR}/node_modules/@flare-desktop/cli/src/lib/project.js")
+set(FLARE_GENERATED_CONFIG "\${CMAKE_CURRENT_BINARY_DIR}/flare-embedded-config.h")
+file(GENERATE OUTPUT "\${CMAKE_CURRENT_BINARY_DIR}/flare-config-selection.txt"
+    CONTENT "\${FLARE_CONFIG_FILE}\n\${FLARE_CONFIG_ENVIRONMENT}\n")
+add_custom_command(
+    OUTPUT "\${FLARE_GENERATED_CONFIG}"
+    COMMAND "\${FLARE_NODE_EXECUTABLE}" "\${FLARE_CONFIG_GENERATOR}"
+            "\${CMAKE_CURRENT_SOURCE_DIR}" "\${FLARE_CONFIG_FILE}" "\${FLARE_CONFIG_ENVIRONMENT}"
+            "\${FLARE_GENERATED_CONFIG}"
+    DEPENDS "\${FLARE_CONFIG_GENERATOR}" "\${FLARE_CONFIG_IMPLEMENTATION}" "\${FLARE_CONFIG_LOADER}"
+            "\${CMAKE_CURRENT_BINARY_DIR}/flare-config-selection.txt" \${FLARE_CONFIG_LAYERS}
+    VERBATIM)
+target_sources(${name} PRIVATE "\${FLARE_GENERATED_CONFIG}")
+target_include_directories(${name} PRIVATE "\${CMAKE_CURRENT_BINARY_DIR}")
 
 set(FLARE_FRONTEND_DIR "frontend" CACHE PATH "Frontend directory")
 file(TO_CMAKE_PATH "\${FLARE_FRONTEND_DIR}" FLARE_FRONTEND_DIR)
@@ -96,13 +129,14 @@ FlareEmbedFrontend(${name} "\${FLARE_FRONTEND_DIR}")
 `;
 }
 
-export function sourceTemplate({ name, identifier, version }) {
+export function sourceTemplate({ name }) {
   const embedded = embeddedIdentifier(name);
   return `#include <flare/config/config.h>
 #include <flare/core/application.h>
 #include <flare/log/log.h>
 
 #include <${name}-frontend.h>
+#include <flare-embedded-config.h>
 
 #include <cstdlib>
 #include <string>
@@ -115,20 +149,9 @@ int main() {
     const bool development = std::getenv("FLARE_DEV") != nullptr;
 
     Flare::ApplicationOptions options;
-    options.config = Flare::Config::Defaults("${identifier}", "${version}");
-    options.config.app.productName = "${name}";
-    options.config.windows.front().title = "${name}";
+    options.config = FlareGenerated::EmbeddedConfig();
     options.development = development;
 
-    std::string error;
-    Flare::ConfigLoader loader(
-        Flare::ConfigMergeOptions{"flare.config.json", development ? "development" : "production", "", {}});
-    if (const auto loaded = loader.Load(error); loaded.has_value()) {
-        options.config = *loaded;
-    } else {
-        Flare::LogWarn("using the built-in configuration: {}", error);
-    }
-
     const char* devUrl = std::getenv("FLARE_DEV_URL");
     if (devUrl != nullptr) options.devUrl = devUrl;
     if (development && options.devUrl.empty()) options.frontendDirectory = FLARE_FRONTEND_DIR;
@@ -150,7 +173,7 @@ int main() {
 `;
 }
 
-export function indexHtmlTemplate(name) {
+export function indexHtmlTemplate(name, template = "javascript") {
   return `<!doctype html>
 <html lang="en">
 <head>
@@ -166,7 +189,7 @@ export function indexHtmlTemplate(name) {
 <button id="greet">call the backend</button>
 <pre id="output"></pre>
 </main>
-<script type="module" src="main.js"></script>
+<script type="module" src="${template === "typescript" ? "main.ts" : "main.js"}"></script>
 </body>
 </html>
 `;
@@ -246,8 +269,44 @@ document.querySelector("#greet").addEventListener("click", async () => {
 `;
 }
 
+export function typescriptTemplate() {
+  return `import { app, invoke } from "/core.js";
+
+const output = document.querySelector<HTMLPreElement>("#output");
+const button = document.querySelector<HTMLButtonElement>("#greet");
+
+button?.addEventListener("click", async () => {
+  const message = await invoke<string>("greet", { name: "flare" });
+  const version = await app.version();
+  if (output) output.textContent = \`\${message} (\${version})\`;
+});
+`;
+}
+
+export function tsconfigTemplate() {
+  return {
+    compilerOptions: {
+      target: "ES2022", lib: ["ES2022", "DOM"], module: "ESNext", moduleResolution: "Bundler",
+      strict: true, noEmit: true, skipLibCheck: true, types: ["vite/client"],
+      paths: { "/core.js": ["./frontend/core.d.ts"] }
+    },
+    include: ["frontend/main.ts"]
+  };
+}
+
+export function viteConfigTemplate() {
+  return `import { defineConfig } from "vite";
+export default defineConfig({
+  root: "frontend",
+  base: "./",
+  build: { outDir: "../dist", emptyOutDir: true },
+  server: { host: "127.0.0.1", port: 5173, strictPort: true }
+});
+`;
+}
+
 export function gitignoreTemplate() {
-  return "build/\ntarget/\nnode_modules/\n.DS_Store\n";
+  return "build/\ntarget/\nnode_modules/\ndist/\n.DS_Store\n";
 }
 
 export function readmeTemplate(name) {
@@ -270,7 +329,7 @@ npm run bundle
 \`\`\`
 
 \`npm run dev\` builds the C++ core and serves \`frontend/\` in the system webview.
-\`npm run build\` compiles the frontend into the executable and produces a release build.
+\`npm run build\` compiles the frontend and the effective typed configuration into the executable. No JSON file is needed at runtime. On Windows, the native webview is enabled automatically. A configuration change requires rebuilding.
 \`npm run bundle\` assembles the configured bundle targets under \`target/bundle\`.
 
 ## Icons