@gtkx/cli 0.18.1 → 0.18.3

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,
+            };
+        },
+    };
+}