@gtkx/cli 0.18.0 → 0.18.2

package/src/refresh-runtime.ts

@@ -0,0 +1,89 @@
+import RefreshRuntime from "react-refresh/runtime";
+
+type ComponentType = (...args: unknown[]) => unknown;
+
+RefreshRuntime.injectIntoGlobalHook(globalThis);
+globalThis.$RefreshReg$ = () => {};
+globalThis.$RefreshSig$ = () => (type: unknown) => type;
+
+/**
+ * Creates registration functions for a module's React components.
+ *
+ * Used internally by the Vite plugin to register components
+ * for React Fast Refresh.
+ *
+ * @param moduleId - Unique identifier for the module
+ * @returns Registration functions for the module
+ * @internal
+ */
+export function createModuleRegistration(moduleId: string): {
+    $RefreshReg$: (type: ComponentType, id: string) => void;
+    $RefreshSig$: typeof RefreshRuntime.createSignatureFunctionForTransform;
+} {
+    return {
+        $RefreshReg$: (type: ComponentType, id: string) => {
+            RefreshRuntime.register(type, `${moduleId} ${id}`);
+        },
+        $RefreshSig$: RefreshRuntime.createSignatureFunctionForTransform,
+    };
+}
+
+function isLikelyComponentType(value: unknown): boolean {
+    if (typeof value !== "function") {
+        return false;
+    }
+
+    const func = value as { $$typeof?: symbol };
+
+    if (func.$$typeof === Symbol.for("react.memo") || func.$$typeof === Symbol.for("react.forward_ref")) {
+        return true;
+    }
+
+    const name = (value as { name?: string }).name;
+    if (typeof name === "string" && /^[A-Z]/.test(name)) {
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * Checks if a module's exports form a React Refresh boundary.
+ *
+ * A module is a refresh boundary if all its exports are React components,
+ * allowing for fast refresh without full page reload.
+ *
+ * @param moduleExports - The module's exports object
+ * @returns `true` if the module can be fast-refreshed
+ * @internal
+ */
+export function isReactRefreshBoundary(moduleExports: Record<string, unknown>): boolean {
+    if (RefreshRuntime.isLikelyComponentType(moduleExports)) {
+        return true;
+    }
+
+    for (const key in moduleExports) {
+        if (key === "__esModule") {
+            continue;
+        }
+
+        const value = moduleExports[key];
+
+        if (!isLikelyComponentType(value)) {
+            return false;
+        }
+    }
+
+    return Object.keys(moduleExports).filter((k) => k !== "__esModule").length > 0;
+}
+
+/**
+ * Triggers React Fast Refresh to re-render components.
+ *
+ * Called after module updates when all exports are React components.
+ *
+ * @internal
+ */
+export function performRefresh(): void {
+    RefreshRuntime.performReactRefresh();
+}

package/src/templates.ts

@@ -0,0 +1,26 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import ejs from "ejs";
+import type { TestingOption } from "./create.js";
+
+export type TemplateContext = {
+    name: string;
+    appId: string;
+    title: string;
+    testing: TestingOption;
+};
+
+const getTemplatesDir = (): string => {
+    return join(import.meta.dirname, "..", "templates");
+};
+
+const renderTemplate = (templatePath: string, context: TemplateContext): string => {
+    const templateContent = readFileSync(templatePath, "utf-8");
+    return ejs.render(templateContent, context);
+};
+
+export const renderFile = (templateName: string, context: TemplateContext): string => {
+    const templatesDir = getTemplatesDir();
+    const templatePath = join(templatesDir, templateName);
+    return renderTemplate(templatePath, context);
+};

package/src/vite-plugin-gtkx-assets.ts

@@ -0,0 +1,32 @@
+import type { Plugin } from "vite";
+
+const ASSET_RE = /\.(png|jpe?g|gif|svg|webp|webm|mp4|ogg|mp3|wav|flac|aac|woff2?|eot|ttf|otf|ico|avif)$/i;
+
+/**
+ * Vite plugin that resolves static asset imports to filesystem paths.
+ *
+ * In dev mode, asset imports resolve to the absolute source file path.
+ * In build mode, Vite's built-in asset pipeline handles emission and
+ * hashing; the `renderBuiltUrl` config in the builder converts the
+ * URL to a filesystem path via `import.meta.url`.
+ */
+export function gtkxAssets(): Plugin {
+    let isBuild = false;
+
+    return {
+        name: "gtkx:assets",
+        enforce: "pre",
+
+        configResolved(config) {
+            isBuild = config.command === "build";
+        },
+
+        load(id) {
+            if (isBuild || !ASSET_RE.test(id)) {
+                return;
+            }
+
+            return `export default ${JSON.stringify(id)};`;
+        },
+    };
+}

package/src/vite-plugin-gtkx-built-url.ts

@@ -0,0 +1,48 @@
+import type { Plugin } from "vite";
+
+/**
+ * Vite plugin that configures `renderBuiltUrl` for resolving asset imports
+ * to filesystem paths at runtime.
+ *
+ * When `assetBase` is provided, assets resolve relative to the executable
+ * directory using `path.join(path.dirname(process.execPath), assetBase, filename)`.
+ * This supports FHS-compliant layouts where assets live in `../share/<app>/`.
+ *
+ * When `assetBase` is omitted, assets resolve relative to the bundle file
+ * via `import.meta.url`, which works when assets are co-located with the
+ * executable.
+ *
+ * Only applies when the user has not already configured
+ * `experimental.renderBuiltUrl` in their Vite config.
+ */
+export function gtkxBuiltUrl(assetBase?: string): Plugin {
+    return {
+        name: "gtkx:built-url",
+
+        config(userConfig) {
+            if (userConfig.experimental?.renderBuiltUrl) {
+                return;
+            }
+
+            return {
+                experimental: {
+                    renderBuiltUrl(filename, { type }) {
+                        if (type !== "asset") {
+                            return;
+                        }
+
+                        if (assetBase) {
+                            return {
+                                runtime: `require("path").join(require("path").dirname(process.execPath),${JSON.stringify(assetBase)},${JSON.stringify(filename)})`,
+                            };
+                        }
+
+                        return {
+                            runtime: `new URL(${JSON.stringify(`./${filename}`)}, import.meta.url).pathname`,
+                        };
+                    },
+                },
+            };
+        },
+    };
+}

package/src/vite-plugin-gtkx-native.ts

@@ -0,0 +1,64 @@
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { arch, platform } from "node:os";
+import { join } from "node:path";
+import type { Plugin } from "vite";
+
+const LOAD_NATIVE_BINDING_RE = /function loadNativeBinding\(\) \{[\s\S]*?\n\}/;
+const NODE_OS_IMPORT_RE = /import\s*\{[^}]*\}\s*from\s*["']node:os["'];?\n?/;
+
+/**
+ * Vite plugin that embeds the native `.node` binary into the build output.
+ *
+ * During production builds, resolves the platform-specific `.node` binary,
+ * copies it into the output directory as `gtkx.node`, and transforms the
+ * `loadNativeBinding` function in `@gtkx/native` to load `./gtkx.node`
+ * directly. This makes the bundle self-contained with no `node_modules`
+ * dependency at runtime.
+ *
+ * @param root - Project root directory used to resolve native packages
+ */
+export function gtkxNative(root: string): Plugin {
+    const projectRequire = createRequire(join(root, "package.json"));
+    let nativeIndexPath: string;
+
+    return {
+        name: "gtkx:native",
+        enforce: "pre",
+
+        buildStart() {
+            const currentPlatform = platform();
+            const currentArch = arch();
+            const packageName = `@gtkx/native-linux-${currentArch}`;
+
+            if (currentPlatform !== "linux") {
+                throw new Error(`Unsupported build platform: ${currentPlatform}. Only Linux is supported.`);
+            }
+
+            if (currentArch !== "x64" && currentArch !== "arm64") {
+                throw new Error(`Unsupported build architecture: ${currentArch}. Only x64 and arm64 are supported.`);
+            }
+
+            nativeIndexPath = projectRequire.resolve("@gtkx/native");
+
+            const nodePath = projectRequire.resolve(`${packageName}/index.node`);
+            const source = readFileSync(nodePath);
+
+            this.emitFile({
+                type: "asset",
+                fileName: "gtkx.node",
+                source,
+            });
+        },
+
+        transform(code, id) {
+            if (id !== nativeIndexPath) {
+                return;
+            }
+
+            return code
+                .replace(NODE_OS_IMPORT_RE, "")
+                .replace(LOAD_NATIVE_BINDING_RE, 'function loadNativeBinding() { return require("./gtkx.node"); }');
+        },
+    };
+}

package/src/vite-plugin-gtkx-refresh.ts

@@ -0,0 +1,54 @@
+import type { Plugin } from "vite";
+
+type GtkxRefreshOptions = {
+    include?: RegExp;
+    exclude?: RegExp;
+};
+
+const defaultInclude = /\.[tj]sx?$/;
+const defaultExclude = /node_modules/;
+
+const refreshRuntimePath = "@gtkx/cli/refresh-runtime";
+
+export function gtkxRefresh(options: GtkxRefreshOptions = {}): Plugin {
+    const include = options.include ?? defaultInclude;
+    const exclude = options.exclude ?? defaultExclude;
+
+    return {
+        name: "gtkx:refresh",
+        enforce: "post",
+
+        transform(code, id, transformOptions) {
+            if (!transformOptions?.ssr) {
+                return;
+            }
+
+            if (!include.test(id)) {
+                return;
+            }
+
+            if (exclude.test(id)) {
+                return;
+            }
+
+            const hasRefreshReg = code.includes("$RefreshReg$");
+            const hasRefreshSig = code.includes("$RefreshSig$");
+
+            if (!hasRefreshReg && !hasRefreshSig) {
+                return;
+            }
+
+            const moduleIdJson = JSON.stringify(id);
+
+            const header = `
+import { createModuleRegistration as __createModuleRegistration__ } from "${refreshRuntimePath}";
+const { $RefreshReg$, $RefreshSig$ } = __createModuleRegistration__(${moduleIdJson});
+`;
+
+            return {
+                code: header + code,
+                map: null,
+            };
+        },
+    };
+}

package/src/vite-plugin-swc-ssr-refresh.ts

@@ -0,0 +1,61 @@
+import { type Options as SwcOptions, transform } from "@swc/core";
+import type { Plugin } from "vite";
+
+type SwcSsrRefreshOptions = {
+    include?: RegExp;
+    exclude?: RegExp;
+};
+
+const defaultInclude = /\.[tj]sx?$/;
+const defaultExclude = /node_modules/;
+
+export function swcSsrRefresh(options: SwcSsrRefreshOptions = {}): Plugin {
+    const include = options.include ?? defaultInclude;
+    const exclude = options.exclude ?? defaultExclude;
+
+    return {
+        name: "gtkx:swc-ssr-refresh",
+        enforce: "pre",
+
+        async transform(code, id, transformOptions) {
+            if (!transformOptions?.ssr) {
+                return;
+            }
+
+            if (!include.test(id)) {
+                return;
+            }
+
+            if (exclude.test(id)) {
+                return;
+            }
+
+            const isTsx = id.endsWith(".tsx");
+            const isTs = id.endsWith(".ts") || isTsx;
+
+            const swcOptions: SwcOptions = {
+                filename: id,
+                sourceFileName: id,
+                sourceMaps: true,
+                jsc: {
+                    parser: isTs ? { syntax: "typescript", tsx: isTsx } : { syntax: "ecmascript", jsx: true },
+                    transform: {
+                        react: {
+                            runtime: "automatic",
+                            development: true,
+                            refresh: true,
+                        },
+                    },
+                    target: "es2022",
+                },
+            };
+
+            const result = await transform(code, swcOptions);
+
+            return {
+                code: result.code,
+                map: result.map,
+            };
+        },
+    };
+}