@gtkx/cli 0.20.0 → 1.0.0-rc.1

package/src/vite-plugins/icons.ts

@@ -0,0 +1,58 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { info } from "@gtkx/utils";
+import type { Plugin, UserConfig } from "vite";
+import { prependBanner } from "../internal/banner.js";
+import { resolveDataDir } from "../internal/data-dir.js";
+import { type ListedFile, listFilesRecursive } from "../internal/list-files.js";
+
+const ICONS_DIR = "icons";
+
+const XDG_ENV_BANNER = [
+    `process.env.XDG_DATA_DIRS = [`,
+    `    decodeURIComponent(new URL(".", import.meta.url).pathname),`,
+    `    process.env.XDG_DATA_DIRS || "/usr/local/share:/usr/share",`,
+    `].join(":");`,
+].join("\n");
+
+type PluginState = {
+    iconsDir: string | null;
+};
+
+const findIconFiles = (iconsDir: string | null): ListedFile[] =>
+    iconsDir === null ? [] : listFilesRecursive(iconsDir);
+
+export function gtkxIcons(): Plugin {
+    const state: PluginState = {
+        iconsDir: null,
+    };
+
+    return {
+        name: "gtkx:icons",
+        enforce: "pre",
+        apply: "build",
+
+        config(config: UserConfig) {
+            const root = config.root ?? process.cwd();
+            const dataDir = resolveDataDir(root);
+            state.iconsDir = dataDir === null ? null : join(root, dataDir, ICONS_DIR);
+        },
+
+        outputOptions(options) {
+            if (findIconFiles(state.iconsDir).length === 0) return;
+            return prependBanner(options, XDG_ENV_BANNER);
+        },
+
+        buildEnd() {
+            const icons = findIconFiles(state.iconsDir);
+            for (const { absPath, rel } of icons) {
+                this.emitFile({
+                    type: "asset",
+                    fileName: join(ICONS_DIR, rel),
+                    source: readFileSync(absPath),
+                });
+            }
+            if (icons.length > 0) info(`Copied ${icons.length} icon(s) into ${ICONS_DIR}/`);
+        },
+    };
+}

package/src/vite-plugins/index.ts

@@ -0,0 +1,22 @@
+import { createConfigLoader } from "@gtkx/config/internal";
+import createConfigPlugin from "@gtkx/config/vite-plugin";
+import type { Plugin } from "vite";
+import { gtkxCss } from "./css.js";
+import { gtkxIcons } from "./icons.js";
+import { gtkxReactCompiler } from "./react-compiler.js";
+import { gtkxResources } from "./resources.js";
+import { gtkxSettings } from "./settings.js";
+import { gtkxUndeclaredLibrary } from "./undeclared-library.js";
+
+export const gtkxVitePlugins = (mode?: string): Plugin[] => {
+    const loadConfig = createConfigLoader(mode !== undefined ? { mode } : {});
+    return [
+        createConfigPlugin({ name: "gtkx:config", loadConfig }),
+        gtkxUndeclaredLibrary(mode),
+        gtkxSettings(),
+        gtkxIcons(),
+        gtkxResources(loadConfig),
+        gtkxCss(),
+        gtkxReactCompiler(loadConfig),
+    ];
+};

package/src/vite-plugins/native.ts

@@ -0,0 +1,74 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { arch, platform } from "node:os";
+import { dirname, join } from "node:path";
+import type { Plugin } from "vite";
+
+const EMITTED_BINDING_SPECIFIER = "./gtkx.node";
+
+function resolveBinaryPath(projectRequire: ReturnType<typeof createRequire>, currentArch: string): string {
+    const nativeRoot = dirname(projectRequire.resolve("@gtkx/native/package.json"));
+    const localBinary = join(nativeRoot, `native.linux-${currentArch}-gnu.node`);
+    return existsSync(localBinary) ? localBinary : projectRequire.resolve(`@gtkx/native-linux-${currentArch}-gnu`);
+}
+
+function resolvePlatformBinary(projectRequire: ReturnType<typeof createRequire>): Buffer {
+    const currentPlatform = platform();
+    const currentArch = arch();
+
+    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`);
+    }
+
+    return readFileSync(resolveBinaryPath(projectRequire, currentArch));
+}
+
+function rewriteLoader(code: string): string {
+    const idents: string[] = [];
+    for (const match of code.matchAll(/export\s*\{\s*([A-Za-z0-9_$]+)\s*\}/g)) {
+        const ident = match[1];
+        if (ident) {
+            idents.push(ident);
+        }
+    }
+    const bindings = idents.join(", ");
+
+    return [
+        `import { createRequire as __gtkxCreateRequire } from "node:module";`,
+        `const __gtkxNative = __gtkxCreateRequire(import.meta.url)(${JSON.stringify(EMITTED_BINDING_SPECIFIER)});`,
+        `const { ${bindings} } = __gtkxNative;`,
+        `export { ${bindings} };`,
+    ].join("\n");
+}
+
+export function gtkxNative(root: string): Plugin {
+    const projectRequire = createRequire(join(root, "package.json"));
+    let cachedLoaderPath: string | undefined;
+
+    const loaderPath = (): string => {
+        cachedLoaderPath ??= join(dirname(projectRequire.resolve("@gtkx/native/package.json")), "index.js");
+        return cachedLoaderPath;
+    };
+
+    return {
+        name: "gtkx:native",
+        enforce: "pre",
+        apply: "build",
+
+        buildStart() {
+            this.emitFile({ type: "asset", fileName: "gtkx.node", source: resolvePlatformBinary(projectRequire) });
+        },
+
+        resolveId(id) {
+            return id === EMITTED_BINDING_SPECIFIER ? { id, external: true } : null;
+        },
+
+        transform(code, id) {
+            return id.replace(/\?.*$/, "") === loaderPath() ? rewriteLoader(code) : null;
+        },
+    };
+}

package/src/vite-plugins/react-compiler.ts

@@ -0,0 +1,70 @@
+/// <reference path="../babel-modules.d.ts" />
+import { transformAsync } from "@babel/core";
+import babelPresetTypescriptNs from "@babel/preset-typescript";
+import type { ResolvedReactCompilerOptions } from "@gtkx/config";
+import { type ConfigLoader, createConfigLoader } from "@gtkx/config/internal";
+import babelPluginReactCompilerNs from "babel-plugin-react-compiler";
+import type { Plugin, ResolvedConfig, UserConfig } from "vite";
+
+const babelPresetTypescript = babelPresetTypescriptNs.default ?? babelPresetTypescriptNs;
+const babelPluginReactCompiler = babelPluginReactCompilerNs.default ?? babelPluginReactCompilerNs;
+
+const SOURCE_EXTENSION = /\.[jt]sx?$/;
+const TYPESCRIPT_EXTENSION = /\.tsx?$/;
+const TYPE_ONLY_EXTENSION = /\.ts$/;
+const NODE_MODULES = /(?:^|\/)node_modules\//;
+
+type ReactCompilerState = {
+    root: string;
+    options: ResolvedReactCompilerOptions | null;
+};
+
+const isProjectSource = (root: string, id: string): boolean => {
+    if (!SOURCE_EXTENSION.test(id)) return false;
+    if (NODE_MODULES.test(id)) return false;
+    if (root !== "" && !id.startsWith(`${root}/`)) return false;
+    return true;
+};
+
+export function gtkxReactCompiler(loadConfig: ConfigLoader = createConfigLoader()): Plugin {
+    const state: ReactCompilerState = {
+        root: "",
+        options: null,
+    };
+
+    return {
+        name: "gtkx:react-compiler",
+        enforce: "pre",
+
+        async config(config: UserConfig) {
+            state.options = (await loadConfig(config.root ?? process.cwd())).reactCompiler;
+        },
+
+        configResolved(config: ResolvedConfig) {
+            state.root = config.root;
+        },
+
+        async transform(code, id) {
+            const options = state.options;
+            if (options === null || !isProjectSource(state.root, id)) {
+                return;
+            }
+
+            const result = await transformAsync(code, {
+                filename: id,
+                babelrc: false,
+                configFile: false,
+                sourceMaps: true,
+                parserOpts: { plugins: TYPE_ONLY_EXTENSION.test(id) ? [] : ["jsx"] },
+                presets: TYPESCRIPT_EXTENSION.test(id) ? [babelPresetTypescript] : [],
+                plugins: [[babelPluginReactCompiler, options]],
+            });
+
+            if (!result?.code) {
+                return;
+            }
+
+            return result.map == null ? { code: result.code } : { code: result.code, map: JSON.stringify(result.map) };
+        },
+    };
+}

package/src/vite-plugins/react-dom-prebundle.ts

@@ -0,0 +1,14 @@
+import type { Plugin } from "vite";
+
+export const gtkxReactDomPrebundle = (): Plugin => ({
+    name: "gtkx:react-dom-prebundle",
+    enforce: "post",
+    config(config) {
+        config.optimizeDeps ??= {};
+        if (config.optimizeDeps.include) {
+            config.optimizeDeps.include = config.optimizeDeps.include.filter(
+                (dep) => dep !== "react-dom" && !dep.startsWith("react-dom/"),
+            );
+        }
+    },
+});

package/src/vite-plugins/resource-init-module.ts

@@ -0,0 +1,54 @@
+import { BUNDLE_FILENAME } from "./resource-shared.js";
+
+const buildInitModuleSource = (): string =>
+    [
+        `import { dirname, join } from "node:path";`,
+        `import { fileURLToPath } from "node:url";`,
+        `import { resourceLoad, resourcesRegister } from "@gtkx/gi/gio";`,
+        ``,
+        `const bundleDir = dirname(fileURLToPath(import.meta.url));`,
+        `const resource = resourceLoad(join(bundleDir, ${JSON.stringify(BUNDLE_FILENAME)}));`,
+        `resourcesRegister(resource);`,
+        ``,
+        `export function ensureRegistered() {}`,
+        `export function __refresh() {}`,
+    ].join("\n");
+
+const devInitModuleSource = (bundlePath: string): string => {
+    const bundlePathLiteral = JSON.stringify(bundlePath);
+    return [
+        `import { existsSync, statSync } from "node:fs";`,
+        `import { resourceLoad, resourcesRegister, resourcesUnregister } from "@gtkx/gi/gio";`,
+        ``,
+        `let current = null;`,
+        `let lastSig = "";`,
+        ``,
+        `function register() {`,
+        `    const next = resourceLoad(${bundlePathLiteral});`,
+        `    if (current) resourcesUnregister(current);`,
+        `    resourcesRegister(next);`,
+        `    current = next;`,
+        `}`,
+        ``,
+        `export function ensureRegistered() {`,
+        `    if (!existsSync(${bundlePathLiteral})) return;`,
+        `    const { size, mtimeMs } = statSync(${bundlePathLiteral});`,
+        `    const sig = size + ":" + mtimeMs;`,
+        `    if (sig === lastSig) return;`,
+        `    register();`,
+        `    lastSig = sig;`,
+        `}`,
+        ``,
+        `ensureRegistered();`,
+        ``,
+        `export function __refresh() {`,
+        `    if (!existsSync(${bundlePathLiteral})) return;`,
+        `    register();`,
+        `    const { size, mtimeMs } = statSync(${bundlePathLiteral});`,
+        `    lastSig = size + ":" + mtimeMs;`,
+        `}`,
+    ].join("\n");
+};
+
+export const renderInitModule = (options: { isBuild: boolean; devBundlePath: string }): string =>
+    options.isBuild ? buildInitModuleSource() : devInitModuleSource(options.devBundlePath);

package/src/vite-plugins/resource-shared.ts

@@ -0,0 +1,27 @@
+import { createVirtualNamespace } from "./virtual-module.js";
+
+const VIRTUAL_PREFIX = "\0gtkx-resources:";
+
+export const VIRTUAL_INIT = "\0gtkx-resources-init";
+
+export const BUNDLE_FILENAME = "gtkx.gresource";
+
+export const REL_SEPARATOR = "\0rel=";
+
+export const { isVirtual, toVirtualId, fromVirtualId } = createVirtualNamespace(VIRTUAL_PREFIX);
+
+export const escapeXml = (value: string): string =>
+    value.replaceAll(/[<>&"']/g, (char) => {
+        switch (char) {
+            case "<":
+                return "&lt;";
+            case ">":
+                return "&gt;";
+            case "&":
+                return "&amp;";
+            case '"':
+                return "&quot;";
+            default:
+                return "&apos;";
+        }
+    });

package/src/vite-plugins/resources.ts

@@ -0,0 +1,272 @@
+import { execFileSync } from "node:child_process";
+import { copyFileSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { type ConfigLoader, createConfigLoader } from "@gtkx/config/internal";
+import { error, formatChildProcessError, info } from "@gtkx/utils";
+import type { Plugin, ResolvedConfig, UserConfig, ViteDevServer } from "vite";
+import { DATA_IMPORT_PREFIX, resolveDataDir } from "../internal/data-dir.js";
+import { type ListedFile, listFilesRecursive } from "../internal/list-files.js";
+import { resolveCliTool } from "../internal/resolve-cli-tool.js";
+import { withStagingDir } from "../internal/staging-dir.js";
+import { ASSET_PATH_RE, ASSET_RE } from "./asset-extensions.js";
+import { renderInitModule } from "./resource-init-module.js";
+import {
+    BUNDLE_FILENAME,
+    escapeXml,
+    fromVirtualId,
+    isVirtual,
+    REL_SEPARATOR,
+    toVirtualId,
+    VIRTUAL_INIT,
+} from "./resource-shared.js";
+
+const DATA_PREFIX = `${DATA_IMPORT_PREFIX}/`;
+
+const RESOURCE_COMPILER = "glib-compile-resources";
+const MANIFEST_PREFIX = "/";
+
+const deriveResourcePrefix = (applicationId: string): string => `/${applicationId.replaceAll(".", "/")}`;
+
+const stripQuery = (source: string): string => {
+    const queryIndex = source.indexOf("?");
+    return queryIndex === -1 ? source : source.slice(0, queryIndex);
+};
+
+type ResourceEntry = {
+    sourcePath: string;
+    stagedRelPath: string;
+    resourcePath: string;
+};
+
+type PluginState = {
+    prefix: string;
+    isBuild: boolean;
+    entries: Map<string, ResourceEntry>;
+    sourcePaths: Set<string>;
+    devStagingDir: string | null;
+    devBundlePath: string;
+    server: ViteDevServer | null;
+    compiledSignature: string;
+    dataDir: string | null;
+};
+
+const compileBundle = (state: PluginState, outputPath: string): Buffer =>
+    withStagingDir("resources", (dir) => {
+        const manifest = stageBundle(dir, state.entries);
+        return runCompiler(dir, manifest, outputPath);
+    });
+
+const stageBundle = (dir: string, entries: Map<string, ResourceEntry>): string => {
+    const fileNodes: string[] = [];
+    for (const entry of entries.values()) {
+        const targetPath = join(dir, entry.stagedRelPath);
+        mkdirSync(dirname(targetPath), { recursive: true });
+        copyFileSync(entry.sourcePath, targetPath);
+        fileNodes.push(`        <file>${escapeXml(entry.stagedRelPath)}</file>`);
+    }
+    const prefix = escapeXml(MANIFEST_PREFIX);
+    const manifest = join(dir, "gtkx.gresource.xml");
+    const xml = [
+        `<?xml version="1.0" encoding="UTF-8"?>`,
+        `<gresources>`,
+        `    <gresource prefix="${prefix}">`,
+        ...fileNodes,
+        `    </gresource>`,
+        `</gresources>`,
+        ``,
+    ].join("\n");
+    writeFileSync(manifest, xml);
+    return manifest;
+};
+
+const runCompiler = (sourceDir: string, manifest: string, outputPath: string): Buffer => {
+    try {
+        execFileSync(resolveCliTool(RESOURCE_COMPILER), [
+            `--sourcedir=${sourceDir}`,
+            `--target=${outputPath}`,
+            manifest,
+        ]);
+    } catch (error) {
+        const details = formatChildProcessError(error);
+        throw new Error(`${RESOURCE_COMPILER} failed${details ? `:\n${details}` : ""}`, { cause: error });
+    }
+    return readFileSync(outputPath);
+};
+
+const ensureStagingDir = (state: PluginState): void => {
+    if (!state.devStagingDir) {
+        state.devStagingDir = mkdtempSync(join(tmpdir(), "gtkx-resources-dev-"));
+        state.devBundlePath = join(state.devStagingDir, BUNDLE_FILENAME);
+    }
+};
+
+const entriesSignature = (state: PluginState): string =>
+    [...state.entries.keys()].sort((a, b) => a.localeCompare(b)).join("\0");
+
+const compileDevBundle = (state: PluginState): void => {
+    ensureStagingDir(state);
+    if (state.entries.size === 0) return;
+    compileBundle(state, state.devBundlePath);
+    state.compiledSignature = entriesSignature(state);
+};
+
+const reregisterDevBundle = async (state: PluginState): Promise<void> => {
+    const server = state.server;
+    if (!server) return;
+    const mod = (await server.ssrLoadModule(VIRTUAL_INIT)) as { __refresh?: () => void };
+    mod.__refresh?.();
+};
+
+const scanDataAssets = (dataDir: string): ListedFile[] => listFilesRecursive(dataDir, (name) => ASSET_RE.test(name));
+
+const primeDevBundle = (state: PluginState): void => {
+    if (state.dataDir === null) return;
+    for (const { absPath, rel } of scanDataAssets(state.dataDir)) {
+        registerEntry(state, absPath, rel);
+    }
+    compileDevBundle(state);
+};
+
+const registerDevAsset = (state: PluginState): void => {
+    if (entriesSignature(state) !== state.compiledSignature) {
+        compileDevBundle(state);
+    }
+};
+
+const registerEntry = (state: PluginState, absPath: string, rel: string): ResourceEntry => {
+    const existing = state.entries.get(absPath);
+    if (existing) return existing;
+
+    const resourcePath = `${state.prefix}/${rel}`;
+    const entry: ResourceEntry = {
+        sourcePath: absPath,
+        stagedRelPath: resourcePath.replace(/^\/+/, ""),
+        resourcePath,
+    };
+    state.entries.set(absPath, entry);
+    state.sourcePaths.add(absPath);
+    return entry;
+};
+
+const isTrackedSource = (state: PluginState, file: string): boolean => state.sourcePaths.has(file);
+
+const loadAssetModule = (state: PluginState, virtualId: string): string => {
+    const rest = fromVirtualId(virtualId);
+    const separatorIndex = rest.indexOf(REL_SEPARATOR);
+    const absPath = rest.slice(0, separatorIndex);
+    const rel = rest.slice(separatorIndex + REL_SEPARATOR.length);
+    const entry = registerEntry(state, absPath, rel);
+    const uri = `resource://${entry.resourcePath}`;
+
+    if (!state.isBuild) {
+        registerDevAsset(state);
+    }
+
+    return [
+        `import { ensureRegistered } from ${JSON.stringify(VIRTUAL_INIT)};`,
+        `ensureRegistered();`,
+        `export default ${JSON.stringify(uri)};`,
+        `export const path = ${JSON.stringify(entry.resourcePath)};`,
+    ].join("\n");
+};
+
+const emitBuildBundle = (
+    ctx: { emitFile: (asset: { type: "asset"; fileName: string; source: Buffer }) => string },
+    state: PluginState,
+): void => {
+    if (!state.isBuild || state.entries.size === 0) return;
+    const compiled = withStagingDir("resources-out", (outDir) => compileBundle(state, join(outDir, BUNDLE_FILENAME)));
+    ctx.emitFile({ type: "asset", fileName: BUNDLE_FILENAME, source: compiled });
+    info(`Compiled ${state.entries.size} resource(s) into ${BUNDLE_FILENAME}`);
+};
+
+const refreshDevRegistration = async (state: PluginState): Promise<void> => {
+    compileDevBundle(state);
+    try {
+        await reregisterDevBundle(state);
+    } catch (cause) {
+        error("Failed to refresh GResource bundle:", cause);
+    }
+};
+
+const resolveResourceConfig = async (state: PluginState, config: UserConfig, loadConfig: ConfigLoader) => {
+    const { applicationId } = await loadConfig(config.root ?? process.cwd());
+    state.prefix = deriveResourcePrefix(applicationId);
+    return {
+        assetsInclude: [ASSET_RE],
+    };
+};
+
+const attachResourceWatcher = (state: PluginState, server: ViteDevServer): void => {
+    state.server = server;
+    const onFileEvent = (file: string): void => {
+        if (!isTrackedSource(state, file)) return;
+        refreshDevRegistration(state).catch((cause) => {
+            error("GResource refresh failed:", cause);
+        });
+    };
+    server.watcher.on("change", onFileEvent);
+    server.watcher.on("add", onFileEvent);
+};
+
+export function gtkxResources(loadConfig: ConfigLoader = createConfigLoader()): Plugin {
+    const state: PluginState = {
+        prefix: "",
+        isBuild: false,
+        entries: new Map(),
+        sourcePaths: new Set(),
+        devStagingDir: null,
+        devBundlePath: "",
+        server: null,
+        compiledSignature: "",
+        dataDir: null,
+    };
+
+    return {
+        name: "gtkx:resources",
+        enforce: "pre",
+
+        config(config: UserConfig) {
+            return resolveResourceConfig(state, config, loadConfig);
+        },
+
+        configResolved(config: ResolvedConfig) {
+            state.isBuild = config.command === "build";
+            if (!state.isBuild) {
+                const relativeDataDir = resolveDataDir(config.root);
+                state.dataDir = relativeDataDir === null ? null : join(config.root, relativeDataDir);
+            }
+        },
+
+        configureServer(server) {
+            attachResourceWatcher(state, server);
+            primeDevBundle(state);
+        },
+
+        async resolveId(source, importer, opts) {
+            if (source === VIRTUAL_INIT) return VIRTUAL_INIT;
+            const clean = stripQuery(source);
+            if (!clean.startsWith(DATA_PREFIX) || !ASSET_PATH_RE.test(clean)) return;
+
+            const resolved = await this.resolve(clean, importer, { ...opts, skipSelf: true });
+            if (!resolved || resolved.external) return;
+
+            const rel = clean.slice(DATA_PREFIX.length);
+            return toVirtualId(resolved.id) + REL_SEPARATOR + rel;
+        },
+
+        load(id) {
+            if (id === VIRTUAL_INIT) {
+                if (!state.isBuild) ensureStagingDir(state);
+                return renderInitModule({ isBuild: state.isBuild, devBundlePath: state.devBundlePath });
+            }
+            if (!isVirtual(id)) return;
+            return loadAssetModule(state, id);
+        },
+
+        buildEnd() {
+            emitBuildBundle(this, state);
+        },
+    };
+}

package/src/vite-plugins/settings-worker-env.ts

@@ -0,0 +1,25 @@
+import type { UserConfig } from "vite";
+import type { Plugin } from "vitest/config";
+import { resolveDataDir } from "../internal/data-dir.js";
+import { prependSchemaDir, stageAndCompileProjectSchemas } from "../settings/schema.js";
+
+export function gtkxSettingsWorkerEnv(): Plugin {
+    return {
+        name: "gtkx:settings-worker-env",
+        enforce: "pre",
+
+        config(config: UserConfig) {
+            const root = config.root ?? process.cwd();
+            const dir = stageAndCompileProjectSchemas(root, resolveDataDir(root));
+            if (dir === null) return;
+
+            process.env.GTKX_DEV_SCHEMA_DIR = dir;
+
+            return {
+                test: {
+                    env: { GSETTINGS_SCHEMA_DIR: prependSchemaDir(dir, process.env.GSETTINGS_SCHEMA_DIR) },
+                },
+            };
+        },
+    };
+}