@gtkx/cli 2.0.0-beta.6 → 2.0.0-beta.8

package/src/vite-plugins/font.ts

@@ -0,0 +1,165 @@
+import type { Plugin, Rollup } from "vite";
+import { readFileSync } from "node:fs";
+import { parseSync } from "vite";
+import type { AssetEmitter } from "./asset-emitter.js";
+import { prependBanner } from "../internal/banner.js";
+import { fontFileName, FONTS_DIR } from "../internal/font-path.js";
+import { stagedFontStatus } from "../internal/font-staging.js";
+import { sourceLanguage } from "../internal/source-imports.js";
+import { xdgDataDirsBanner } from "../internal/xdg-banner.js";
+import { parseFontSpecifier } from "./asset-specifier.js";
+import { fontFamilyNames } from "./font-name.js";
+import { stripQuery } from "./strip-query.js";
+import { createVirtualNamespace } from "./virtual-module.js";
+
+type PluginState = {
+    isBuild: boolean;
+    root: string;
+    emitted: Set<string>;
+    importers: Map<string, string>;
+};
+
+type ResolveContext = Parameters<typeof resolveToVirtual>[0];
+type ResolveRequest = Parameters<typeof resolveToVirtual>[1];
+
+type RetainedFontModuleId = {
+    id: string;
+    moduleSideEffects: true;
+};
+
+type LoadContext = AssetEmitter & {
+    addWatchFile: (file: string) => void;
+    error: (message: string) => never;
+};
+
+const VIRTUAL_PREFIX = "\0gtkx-font:";
+const { isVirtual, fromVirtualId, resolveToVirtual } = createVirtualNamespace(VIRTUAL_PREFIX);
+
+const unreadableFontError = (filePath: string): string =>
+    `Cannot read a font family name from ${filePath}; ?font expects a TrueType, OpenType, ` +
+    "TrueType Collection, WOFF, or WOFF2 font";
+
+const unstagedFontError = (filePath: string, importer: string): string =>
+    `${filePath} was not staged before the toolkit started, so ${importer} would resolve its family to a ` +
+    "fallback font. Fonts are staged from ?font imports found in source files under the project root; move " +
+    "the import there, or restart to pick it up.";
+
+const resolveFontId = async (
+    ctx: ResolveContext,
+    state: PluginState,
+    request: ResolveRequest,
+): Promise<RetainedFontModuleId | undefined> => {
+    if (parseFontSpecifier(request.source) === null) {
+        return undefined;
+    }
+
+    const virtualId = await resolveToVirtual(ctx, request);
+
+    if (virtualId === undefined) {
+        return undefined;
+    }
+
+    state.importers.set(virtualId, request.importer ?? state.root);
+
+    return { id: virtualId, moduleSideEffects: true };
+};
+
+const emitFont = (ctx: LoadContext, state: PluginState, filePath: string, content: Buffer): void => {
+    const fileName = `${FONTS_DIR}/${fontFileName(filePath, content)}`;
+
+    if (state.emitted.has(fileName)) {
+        return;
+    }
+
+    state.emitted.add(fileName);
+    ctx.emitFile({ type: "asset", fileName, source: content });
+};
+
+const loadFontModule = (ctx: LoadContext, state: PluginState, id: string): string | undefined => {
+    if (!isVirtual(id)) {
+        return undefined;
+    }
+
+    const filePath = stripQuery(fromVirtualId(id));
+    const content = readFileSync(filePath);
+    const [family] = fontFamilyNames(content);
+
+    if (family === undefined) {
+        return ctx.error(unreadableFontError(filePath));
+    }
+
+    ctx.addWatchFile(filePath);
+
+    if (state.isBuild) {
+        emitFont(ctx, state, filePath, content);
+    } else if (stagedFontStatus(filePath, content) === "absent") {
+        return ctx.error(unstagedFontError(filePath, state.importers.get(id) ?? state.root));
+    }
+
+    return `export default ${JSON.stringify(family)};`;
+};
+
+const hasSideEffectFontImport = (code: string, id: string): boolean => {
+    const lang = sourceLanguage(stripQuery(id));
+
+    if (lang === undefined || !code.includes("?font")) {
+        return false;
+    }
+
+    const parsed = parseSync(id, code, { lang });
+
+    if (parsed.errors.length > 0) {
+        return false;
+    }
+
+    return parsed.module.staticImports.some(
+        (statement) => statement.entries.length === 0 && parseFontSpecifier(statement.moduleRequest.value) !== null,
+    );
+};
+
+const retainSideEffectFontImport = (
+    code: string,
+    id: string,
+): { code: string; moduleSideEffects: true } | null =>
+    hasSideEffectFontImport(code, id)
+        ? { code, moduleSideEffects: true }
+        : null;
+
+const fontBanner = (state: PluginState) => (chunk: Rollup.RenderedChunk): string =>
+    state.emitted.size === 0 ? "" : xdgDataDirsBanner(chunk);
+
+function gtkxFont(): Plugin {
+    const state: PluginState = { isBuild: false, root: "", emitted: new Set(), importers: new Map() };
+
+    return {
+        name: "gtkx:font",
+        enforce: "pre",
+
+        configResolved(config) {
+            state.isBuild = config.command === "build";
+            state.root = config.root;
+        },
+
+        resolveId(source, importer, options) {
+            return resolveFontId(this, state, { source, importer, options });
+        },
+
+        load(id) {
+            return loadFontModule(this, state, id);
+        },
+
+        transform(code, id) {
+            return retainSideEffectFontImport(code, id);
+        },
+
+        outputOptions(options) {
+            if (!state.isBuild) {
+                return;
+            }
+
+            return prependBanner(options, fontBanner(state));
+        },
+    };
+}
+
+export { gtkxFont };

package/src/vite-plugins/icons.ts

@@ -1,17 +1,18 @@
 import type { ConfigLoader } from "@gtkx/config";
-import type { Plugin, Rollup, UserConfig } from "vite";
-import { createConfigLoader } from "@gtkx/config/internal";
+import type { Plugin, UserConfig } from "vite";
+import { createConfigLoader, viteProjectRoot } from "@gtkx/config/internal";
 import { info } from "@gtkx/utils";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import type { AssetEmitter } from "./asset-emitter.js";
-import { outputRootUrlExpression, prependBanner } from "../internal/banner.js";
+import { prependBanner } from "../internal/banner.js";
 import {
     relativeIconPath,
     resolveApplicationIcon,
     type ResolvedApplicationIcon,
 } from "../internal/icon-path.js";
 import { type ListedFile, listFilesRecursive } from "../internal/list-files.js";
+import { xdgDataDirsBanner } from "../internal/xdg-banner.js";
 
 type PluginState = {
     applicationId: string;
@@ -20,13 +21,6 @@ type PluginState = {
 
 const ICONS_DIR = "icons";
 
-const xdgEnvBanner = (chunk: Rollup.RenderedChunk): string => [
-    "globalThis.process.env.XDG_DATA_DIRS = [",
-    `    ${outputRootUrlExpression(chunk)},`,
-    "    globalThis.process.env.XDG_DATA_DIRS || \"/usr/local/share:/usr/share\",",
-    "].join(\":\");",
-].join("\n");
-
 const findIconFiles = (state: PluginState): ListedFile[] => {
     if (state.source.kind === "theme") {
         return listFilesRecursive(state.source.path);
@@ -43,7 +37,7 @@ const findIconFiles = (state: PluginState): ListedFile[] => {
 };
 
 const applyUserConfig = async (state: PluginState, config: UserConfig, loadConfig: ConfigLoader): Promise<void> => {
-    const { config: gtkxConfig, root } = await loadConfig.load(config.root ?? process.cwd());
+    const { config: gtkxConfig, root } = await loadConfig.load(viteProjectRoot(config));
     state.applicationId = gtkxConfig.applicationId;
     state.source = resolveApplicationIcon(root, gtkxConfig.applicationId, gtkxConfig.applicationIcon);
 };
@@ -78,7 +72,7 @@ function gtkxIcons(loadConfig: ConfigLoader = createConfigLoader()): Plugin {
                 return;
             }
 
-            return prependBanner(options, xdgEnvBanner);
+            return prependBanner(options, xdgDataDirsBanner);
         },
 
         buildEnd() {

package/src/vite-plugins/index.ts

@@ -5,6 +5,7 @@ import type { BuildManifestCollector } from "../internal/build-manifest.js";
 import { gtkxAssetImports } from "./asset-imports.js";
 import { gtkxBuiltUrl } from "./built-url.js";
 import { gtkxCss } from "./css.js";
+import { gtkxFont } from "./font.js";
 import { type CatalogWriteListener, gtkxI18n } from "./i18n.js";
 import { gtkxIcons } from "./icons.js";
 import { gtkxReactCompiler } from "./react-compiler.js";
@@ -53,6 +54,7 @@ const gtkxVitePlugins = (options: GtkxVitePluginOptions = {}): Plugin[] => {
         gtkxIcons(loadConfig),
         gtkxAssetImports(),
         gtkxBuiltUrl(),
+        gtkxFont(),
         gtkxResources(loadConfig, entryPath),
         gtkxCss(),
         gtkxReactCompiler(loadConfig),

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

@@ -3,7 +3,7 @@ import type { ResolvedReactCompilerOptions } from "@gtkx/config/internal";
 import type { Plugin, ResolvedConfig, UserConfig } from "vite";
 import { transformAsync } from "@babel/core";
 import babelPresetTypescriptNs from "@babel/preset-typescript";
-import { createConfigLoader } from "@gtkx/config/internal";
+import { createConfigLoader, viteProjectRoot } from "@gtkx/config/internal";
 import babelPluginReactCompilerNs from "babel-plugin-react-compiler";
 
 type ReactCompilerState = {
@@ -62,7 +62,7 @@ function gtkxReactCompiler(loadConfig: ConfigLoader = createConfigLoader()): Plu
         enforce: "pre",
 
         async config(config: UserConfig) {
-            const resolved = await loadConfig.resolve(config.root ?? process.cwd());
+            const resolved = await loadConfig.resolve(viteProjectRoot(config));
             state.options = resolved.reactCompiler;
         },
 

package/src/vite-plugins/resources.ts

@@ -1,6 +1,6 @@
 import type { ConfigLoader } from "@gtkx/config";
 import type { ModuleNode, Plugin, ResolvedConfig, Rolldown, UserConfig, ViteDevServer } from "vite";
-import { createConfigLoader, resourceBasePath } from "@gtkx/config/internal";
+import { createConfigLoader, resourceBasePath, viteProjectRoot } from "@gtkx/config/internal";
 import { error, info, isPathInside, isRecord, sortStrings, toPosixPath } from "@gtkx/utils";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { basename, dirname, extname, isAbsolute, join, posix, relative, sep } from "node:path";
@@ -1283,7 +1283,7 @@ const reconcileImporter = async (ctx: ResolveContext, state: PluginState, id: st
 };
 
 const resolveResourceConfig = async (state: PluginState, config: UserConfig, loadConfig: ConfigLoader) => {
-    const loaded = await loadConfig.load(config.root ?? process.cwd());
+    const loaded = await loadConfig.load(viteProjectRoot(config));
     state.prefix = resourceBasePath(loaded.config.applicationId);
     state.root = loaded.root;
 
@@ -1383,7 +1383,7 @@ const rejectInvalidSpecifier = (source: string): void => {
     if (isBareRelativeAsset(source)) {
         throw new Error(
             `${JSON.stringify(source)} must choose ?resource for a GResource, ?icon for a themed icon, ` +
-            "or ?url for an emitted file",
+            "?font for a bundled font, or ?url for an emitted file",
         );
     }
 };

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

@@ -1,6 +1,6 @@
 import type { UserConfig } from "vite";
 import type { Plugin } from "vitest/config";
-import { createConfigLoader } from "@gtkx/config/internal";
+import { createConfigLoader, viteProjectRoot } from "@gtkx/config/internal";
 import { prependSchemaDir, stageAndCompileProjectSchemas } from "../settings/schema.js";
 
 function gtkxSettingsWorkerEnv(configFile?: string): Plugin {
@@ -11,7 +11,7 @@ function gtkxSettingsWorkerEnv(configFile?: string): Plugin {
         enforce: "pre",
 
         async config(config: UserConfig) {
-            const loaded = await loadConfig.load(config.root ?? process.cwd());
+            const loaded = await loadConfig.load(viteProjectRoot(config));
             const dir = stageAndCompileProjectSchemas(loaded.root);
 
             if (dir === null) {

package/src/vite-plugins/store-links.ts

@@ -1,5 +1,6 @@
 import type { Plugin, UserConfig } from "vite";
 import { ensureStoreLinks } from "@gtkx/codegen/internal";
+import { viteProjectRoot } from "@gtkx/config/internal";
 
 const GENERATED_MODULE_PREFIX = /^@gtkx\/(?:gi\/|jsx(?:\/|$))/;
 
@@ -11,7 +12,7 @@ function gtkxStoreLinks(): Plugin {
         enforce: "pre",
 
         config(config: UserConfig) {
-            state.root = config.root ?? process.cwd();
+            state.root = viteProjectRoot(config);
         },
 
         resolveId(source) {

package/src/vite-plugins/undeclared-library.ts

@@ -2,7 +2,7 @@ import type { StoreOptions } from "@gtkx/codegen";
 import type { ConfigLoader } from "@gtkx/config";
 import type { Plugin, UserConfig } from "vite";
 import { discoverGirNamespaces, resolveGirPath, resolveStore } from "@gtkx/codegen";
-import { createConfigLoader } from "@gtkx/config/internal";
+import { createConfigLoader, viteProjectRoot } from "@gtkx/config/internal";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
@@ -20,7 +20,7 @@ type GeneratedModule = {
 };
 
 const GENERATED_MODULE_PATTERN = /^@gtkx\/(gi|jsx)\/([a-z0-9]+)$/;
-const DEFAULT_LIBRARY_NAMESPACES: Set<string> = new Set(["gtk", "adw"]);
+const DEFAULT_LIBRARY_NAMESPACES: Set<string> = new Set(["adw", "gtk"]);
 
 const girSearchPaths = async (state: PluginState): Promise<string[]> => {
     if (state.girPath === null) {
@@ -88,7 +88,7 @@ const undeclaredLibraryError = (source: string, namespace: string, girPath: stri
         return new Error(
             `Cannot resolve "${source}": the binding store has no "${namespace}" module, and no ` +
             `GIR data for it was found in [${girPath.join(", ")}]. If "${namespace}" is a library, install ` +
-            "its gobject-introspection data package. Gtk-4.0 and Adw-1 are bound by default; add only other " +
+            "its gobject-introspection data package. Adw-1 is bound by default and pulls in Gtk-4.0; add only other " +
             "GIR identifiers to `libraries` in gtkx.config.ts. Otherwise run gtkx codegen to regenerate the store.",
         );
     }
@@ -96,7 +96,7 @@ const undeclaredLibraryError = (source: string, namespace: string, girPath: stri
     if (DEFAULT_LIBRARY_NAMESPACES.has(namespace)) {
         return new Error(
             `Cannot resolve "${source}": the "${identifier}" bindings have not been generated. ` +
-            "The Gtk and Adwaita namespaces are bound by default; run gtkx dev or gtkx build again.",
+            "The Adwaita and GTK namespaces are generated implicitly; run gtkx dev or gtkx build again.",
         );
     }
 
@@ -129,7 +129,7 @@ function gtkxUndeclaredLibrary(loadConfig: ConfigLoader = createConfigLoader()):
         enforce: "pre",
 
         config(config: UserConfig) {
-            state.root = config.root ?? process.cwd();
+            state.root = viteProjectRoot(config);
         },
 
         async resolveId(source, importer, options) {

package/src/vitest-plugin.ts

@@ -1,6 +1,7 @@
 import type { Plugin } from "vite";
 import gtkxVitest, { type PluginOptions } from "@gtkx/vitest";
 import { gtkxEnsureStore } from "./vite-plugins/ensure-store.js";
+import { gtkxFontWorkerEnv } from "./vite-plugins/font-worker-env.js";
 import { gtkxVitePlugins } from "./vite-plugins/index.js";
 import { gtkxSettingsWorkerEnv } from "./vite-plugins/settings-worker-env.js";
 
@@ -15,6 +16,7 @@ const gtkx = (options: PluginOptions = {}): Plugin[] => [
     gtkxEnsureStore(options.configFile),
     ...gtkxVitePlugins({ configFile: options.configFile }),
     gtkxSettingsWorkerEnv(options.configFile),
+    gtkxFontWorkerEnv(options.configFile),
     gtkxVitest(options),
 ];