@gtkx/cli 0.21.0 → 1.0.0-rc.2

package/src/vite-plugins/built-url.ts

@@ -0,0 +1,50 @@
+import type { Plugin } from "vite";
+
+const renderAssetUrl = (
+    filename: string,
+    type: string,
+    assetBase: string | undefined,
+): { runtime: string } | undefined => {
+    if (type !== "asset") {
+        return undefined;
+    }
+
+    if (assetBase) {
+        const executableDir = "require(\"path\").dirname(process.execPath)";
+
+        return {
+            runtime:
+                `require("path").join(${executableDir},` +
+                `${JSON.stringify(assetBase)},${JSON.stringify(filename)})`,
+        };
+    }
+
+    const filenameLiteral = JSON.stringify(`./${filename}`);
+
+    return {
+        runtime: `new URL(${filenameLiteral}, import.meta.url).pathname`,
+    };
+};
+
+function gtkxBuiltUrl(assetBase?: string): Plugin {
+    return {
+        name: "gtkx:built-url",
+        apply: "build",
+
+        config(userConfig) {
+            if (userConfig.experimental?.renderBuiltUrl) {
+                return;
+            }
+
+            return {
+                experimental: {
+                    renderBuiltUrl(filename, { type }) {
+                        return renderAssetUrl(filename, type, assetBase);
+                    },
+                },
+            };
+        },
+    };
+}
+
+export { gtkxBuiltUrl };

package/src/vite-plugins/css.ts

@@ -0,0 +1,53 @@
+import type { Plugin } from "vite";
+import { readFileSync } from "node:fs";
+import { createVirtualNamespace } from "./virtual-module.js";
+
+type CssResolveContext = Parameters<typeof resolveToVirtual>[0];
+type CssResolveRequest = Parameters<typeof resolveToVirtual>[1];
+
+const CSS_RE = /\.css$/i;
+const INJECT_SUFFIX = "?inject";
+const VIRTUAL_PREFIX = "\0gtkx-css:";
+const { isVirtual, fromVirtualId, resolveToVirtual } = createVirtualNamespace(VIRTUAL_PREFIX);
+
+const resolveCssId = async (ctx: CssResolveContext, request: CssResolveRequest): Promise<string | undefined> => {
+    if (!CSS_RE.test(request.source)) {
+        return;
+    }
+
+    const virtualId = await resolveToVirtual(ctx, request);
+
+    if (virtualId === undefined) {
+        return;
+    }
+
+    return virtualId + INJECT_SUFFIX;
+};
+
+const loadInjectedCss = (id: string): string | undefined => {
+    if (!isVirtual(id) || !id.endsWith(INJECT_SUFFIX)) {
+        return;
+    }
+
+    const filePath = fromVirtualId(id.slice(0, -INJECT_SUFFIX.length));
+    const content = readFileSync(filePath, "utf8");
+
+    return ["import { injectGlobal } from \"@gtkx/css\";", `injectGlobal(${JSON.stringify(content)});`].join("\n");
+};
+
+function gtkxCss(): Plugin {
+    return {
+        name: "gtkx:css",
+        enforce: "pre",
+
+        resolveId(source, importer, options) {
+            return resolveCssId(this, { source, importer, options });
+        },
+
+        load(id) {
+            return loadInjectedCss(id);
+        },
+    };
+}
+
+export { gtkxCss };

package/src/vite-plugins/fast-refresh/refresh-filter.ts

@@ -0,0 +1,26 @@
+const REFRESH_REG = "$RefreshReg$";
+const REFRESH_SIG = "$RefreshSig$";
+const REFRESH_RUNTIME_SPECIFIER = "@gtkx/cli/refresh-runtime";
+const REFRESH_INCLUDE = /\.[tj]sx?$/;
+const REFRESH_EXCLUDE = /node_modules|[/\\]dist[/\\]|[/\\]\.gtkx[/\\]/;
+
+const shouldTransformForRefresh = (
+    id: string,
+    transformOptions: { ssr?: boolean | undefined } | undefined,
+): boolean => {
+    if (!transformOptions?.ssr) {
+        return false;
+    }
+
+    if (!REFRESH_INCLUDE.test(id)) {
+        return false;
+    }
+
+    if (REFRESH_EXCLUDE.test(id)) {
+        return false;
+    }
+
+    return true;
+};
+
+export { REFRESH_REG, REFRESH_SIG, REFRESH_RUNTIME_SPECIFIER, shouldTransformForRefresh };

package/src/vite-plugins/fast-refresh/swc-refresh.ts

@@ -0,0 +1,92 @@
+import type { Plugin } from "vite";
+import { type Output, type Options as SwcOptions, transform } from "@swc/core";
+import { fileURLToPath } from "node:url";
+import { REFRESH_REG, REFRESH_RUNTIME_SPECIFIER, REFRESH_SIG, shouldTransformForRefresh } from "./refresh-filter.js";
+
+const buildSwcOptions = (id: string): SwcOptions => {
+    const isTsx = id.endsWith(".tsx");
+    const isTs = id.endsWith(".ts") || isTsx;
+
+    return {
+        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 buildRefreshResult = (result: Output): { code: string; map?: string } =>
+    result.map === undefined ? { code: result.code } : { code: result.code, map: result.map };
+
+const injectRefreshRegistration = (
+    code: string,
+    id: string,
+    transformOptions: { ssr?: boolean | undefined } | undefined,
+): { code: string; map: null } | undefined => {
+    if (!shouldTransformForRefresh(id, transformOptions)) {
+        return;
+    }
+
+    if (!code.includes(REFRESH_REG) && !code.includes(REFRESH_SIG)) {
+        return;
+    }
+
+    const header = `
+import { createModuleRegistration as __createModuleRegistration__ } from "${REFRESH_RUNTIME_SPECIFIER}";
+const { ${REFRESH_REG}, ${REFRESH_SIG} } = __createModuleRegistration__(${JSON.stringify(id)});
+`;
+
+    return { code: header + code, map: null };
+};
+
+function gtkxSwcRefresh(): Plugin {
+    return {
+        name: "gtkx:swc-refresh",
+        enforce: "pre",
+        apply: "serve",
+
+        async transform(code, id, transformOptions) {
+            if (!shouldTransformForRefresh(id, transformOptions)) {
+                return;
+            }
+
+            const result = await transform(code, buildSwcOptions(id));
+
+            return buildRefreshResult(result);
+        },
+    };
+}
+
+function gtkxRefreshRuntime(): Plugin {
+    return {
+        name: "gtkx:refresh-runtime",
+        enforce: "post",
+        apply: "serve",
+
+        resolveId(id) {
+            if (id !== REFRESH_RUNTIME_SPECIFIER) {
+                return;
+            }
+
+            return fileURLToPath(import.meta.resolve(REFRESH_RUNTIME_SPECIFIER));
+        },
+
+        transform(code, id, transformOptions) {
+            return injectRefreshRegistration(code, id, transformOptions);
+        },
+    };
+}
+
+const gtkxFastRefresh = (): Plugin[] => [gtkxSwcRefresh(), gtkxRefreshRuntime()];
+
+export { gtkxSwcRefresh, gtkxRefreshRuntime, gtkxFastRefresh };

package/src/vite-plugins/icons.ts

@@ -0,0 +1,74 @@
+import type { Plugin, UserConfig } from "vite";
+import { info } from "@gtkx/utils";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { prependBanner } from "../internal/banner.js";
+import { resolveDataDir } from "../internal/data-dir.js";
+import { type ListedFile, listFilesRecursive } from "../internal/list-files.js";
+
+type PluginState = {
+    iconsDir: string | null;
+};
+
+type PluginContext = {
+    emitFile: (file: { type: "asset"; fileName: string; source: Buffer }) => void;
+};
+
+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");
+
+const findIconFiles = (iconsDir: string | null): ListedFile[] =>
+    iconsDir === null ? [] : listFilesRecursive(iconsDir);
+
+const resolveIconsDir = (config: UserConfig): string | null => {
+    const root = config.root ?? process.cwd();
+    const dataDir = resolveDataDir(root);
+
+    return dataDir === null ? null : join(root, dataDir, ICONS_DIR);
+};
+
+const emitIcons = (ctx: PluginContext, icons: ListedFile[]): void => {
+    for (const { absPath, rel } of icons) {
+        ctx.emitFile({ type: "asset", fileName: join(ICONS_DIR, rel), source: readFileSync(absPath) });
+    }
+
+    if (icons.length > 0) {
+        info(`Copied ${String(icons.length)} icon(s) into ${ICONS_DIR}/`);
+    }
+};
+
+function gtkxIcons(): Plugin {
+    const state: PluginState = {
+        iconsDir: null,
+    };
+
+    return {
+        name: "gtkx:icons",
+        enforce: "pre",
+        apply: "build",
+
+        config(config: UserConfig) {
+            state.iconsDir = resolveIconsDir(config);
+        },
+
+        outputOptions(options) {
+            if (findIconFiles(state.iconsDir).length === 0) {
+                return;
+            }
+
+            return prependBanner(options, XDG_ENV_BANNER);
+        },
+
+        buildEnd() {
+            emitIcons(this, findIconFiles(state.iconsDir));
+        },
+    };
+}
+
+export { gtkxIcons };

package/src/vite-plugins/index.ts

@@ -0,0 +1,25 @@
+import type { Plugin } from "vite";
+import { createConfigLoader } from "@gtkx/config/internal";
+import createConfigPlugin from "@gtkx/config/vite-plugin";
+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";
+
+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),
+    ];
+};
+
+export { gtkxVitePlugins };

package/src/vite-plugins/native.ts

@@ -0,0 +1,83 @@
+import type { Plugin } from "vite";
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { arch, platform } from "node:os";
+import { dirname, join } from "node:path";
+import { stripQuery } from "./strip-query.js";
+
+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();
+
+    if (currentPlatform !== "linux") {
+        throw new Error(`Unsupported build platform: ${currentPlatform}, only Linux is supported`);
+    }
+
+    const currentArch = arch();
+
+    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");
+}
+
+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 stripQuery(id) === loaderPath() ? rewriteLoader(code) : null;
+        },
+    };
+}
+
+export { gtkxNative };

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

@@ -0,0 +1,84 @@
+import type { ResolvedReactCompilerOptions } from "@gtkx/config";
+import type { Plugin, ResolvedConfig, UserConfig } from "vite";
+import { transformAsync } from "@babel/core";
+import babelPresetTypescriptNs from "@babel/preset-typescript";
+import { type ConfigLoader, createConfigLoader } from "@gtkx/config/internal";
+import babelPluginReactCompilerNs from "babel-plugin-react-compiler";
+
+type ReactCompilerState = {
+    root: string;
+    options: ResolvedReactCompilerOptions | null;
+};
+
+const babelPresetTypescript = babelPresetTypescriptNs.default ?? babelPresetTypescriptNs;
+const babelPluginReactCompiler = babelPluginReactCompilerNs.default ?? babelPluginReactCompilerNs;
+const SOURCE_EXTENSION = /\.[jt]sx?$/;
+const TYPESCRIPT_EXTENSION = /\.tsx?$/;
+const NODE_MODULES = /(?:^|\/)node_modules\//;
+
+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;
+};
+
+const compileSource = async (code: string, id: string, options: ResolvedReactCompilerOptions) => {
+    const result = await transformAsync(code, {
+        filename: id,
+        babelrc: false,
+        configFile: false,
+        sourceMaps: true,
+        parserOpts: { plugins: id.endsWith(".ts") ? [] : ["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) };
+};
+
+function gtkxReactCompiler(loadConfig: ConfigLoader = createConfigLoader()): Plugin {
+    const state: ReactCompilerState = {
+        root: "",
+        options: null,
+    };
+
+    return {
+        name: "gtkx:react-compiler",
+        enforce: "pre",
+
+        async config(config: UserConfig) {
+            const resolved = await loadConfig(config.root ?? process.cwd());
+            state.options = resolved.reactCompiler;
+        },
+
+        configResolved(config: ResolvedConfig) {
+            state.root = config.root;
+        },
+
+        async transform(code, id) {
+            const options = state.options;
+
+            if (options === null || !isProjectSource(state.root, id)) {
+                return;
+            }
+
+            return compileSource(code, id, options);
+        },
+    };
+}
+
+export { gtkxReactCompiler };

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

@@ -0,0 +1,17 @@
+import type { Plugin } from "vite";
+
+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/"),
+            );
+        }
+    },
+});
+
+export { gtkxReactDomPrebundle };

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

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

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

@@ -0,0 +1,40 @@
+import { createVirtualNamespace } from "./virtual-module.js";
+
+const VIRTUAL_PREFIX = "\0gtkx-resources:";
+const VIRTUAL_INIT = "\0gtkx-resources-init";
+const BUNDLE_FILENAME = "gtkx.gresource";
+const REL_SEPARATOR = "\0rel=";
+const REFRESH_EXPORT = "__refresh";
+const { isVirtual, toVirtualId, fromVirtualId } = createVirtualNamespace(VIRTUAL_PREFIX);
+
+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;";
+            }
+        }
+    });
+
+export {
+    VIRTUAL_INIT,
+    BUNDLE_FILENAME,
+    REL_SEPARATOR,
+    REFRESH_EXPORT,
+    escapeXml,
+    isVirtual,
+    toVirtualId,
+    fromVirtualId,
+};