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

package/src/deploy/vendored/appimagetool.ts

@@ -39,7 +39,7 @@ const resolveAppimageTooling = async (arch: string): Promise<AppimageTooling> =>
         url: `${APPIMAGETOOL_URL}/appimagetool-${arch}.AppImage`,
         dest: join(dir, `appimagetool-${arch}`),
         label: `appimagetool ${APPIMAGETOOL_VERSION}`,
-        sha256: digestFor(APPIMAGETOOL_DIGESTS, arch, "appimagetool"),
+        digest: digestFor(APPIMAGETOOL_DIGESTS, arch, "appimagetool"),
         mode: EXECUTABLE_MODE,
     });
 
@@ -47,7 +47,7 @@ const resolveAppimageTooling = async (arch: string): Promise<AppimageTooling> =>
         url: `${RUNTIME_URL}/runtime-${arch}`,
         dest: join(dir, `runtime-${arch}`),
         label: `the AppImage runtime ${RUNTIME_VERSION}`,
-        sha256: digestFor(RUNTIME_DIGESTS, arch, "the AppImage runtime"),
+        digest: digestFor(RUNTIME_DIGESTS, arch, "the AppImage runtime"),
         mode: EXECUTABLE_MODE,
     });
 

package/src/deploy/vendored/nfpm.ts

@@ -56,7 +56,7 @@ const downloadNfpm = async (dir: string, binary: string): Promise<string> => {
         url: `${NFPM_BASE_URL}/${assetName}`,
         dest: join(dir, assetName),
         label: `nfpm ${NFPM_VERSION}`,
-        sha256: digestFor(process.arch),
+        digest: digestFor(process.arch),
     });
 
     extractNfpm(archive, binary);

package/src/dev/font-dir.ts

@@ -0,0 +1,11 @@
+import { stageProjectFonts } from "../internal/font-staging.js";
+import { prependXdgDataDir } from "../internal/xdg-data-dirs.js";
+
+const prepareDevFontDir = (root: string): string => {
+    const shareDir = stageProjectFonts(root);
+    process.env.XDG_DATA_DIRS = prependXdgDataDir(shareDir, process.env.XDG_DATA_DIRS);
+
+    return shareDir;
+};
+
+export { prepareDevFontDir };

package/src/dev/runner-main.ts

@@ -2,6 +2,7 @@ import { loadConfig } from "@gtkx/config";
 import { error } from "@gtkx/utils";
 import { resolve } from "node:path";
 import { DEV_CONFIG_ENV, DEV_ENTRY_ENV } from "./entry-env.js";
+import { prepareDevFontDir } from "./font-dir.js";
 import { prepareDevIconDir } from "./icon-dir.js";
 import { prepareDevLocaleDir } from "./locale-dir.js";
 import { createDevRunner } from "./runner.js";
@@ -33,6 +34,7 @@ const main = async (): Promise<void> => {
     prepareDevLocaleDir(root, config.applicationId);
     prepareDevSchemaDir(root);
     prepareDevIconDir(root, config.applicationId, config.applicationIcon);
+    prepareDevFontDir(root);
     const entryPath = resolve(cwd, entryArg);
     const { defaultDevRunnerDeps } = await import("./runner-deps.js");
     const runner = createDevRunner(defaultDevRunnerDeps(configFile));

package/src/dev/runner.ts

@@ -2,6 +2,7 @@ import type { ApplicationInstance } from "@gtkx/runtime/internal";
 import type { InlineConfig, Plugin } from "vite";
 import { error, warn } from "@gtkx/utils";
 import { isCatalogSource } from "../i18n/catalogs.js";
+import { hasUnstagedFontImport } from "../internal/font-staging.js";
 import { loadModuleExclusively, withExclusiveLoad } from "../internal/module-loads.js";
 import { createChangeQueue, type WatchedChange } from "./change-queue.js";
 import { createFailureTracker, type FailureTracker } from "./failure-tracker.js";
@@ -371,6 +372,11 @@ const restartForServerConfig = async (session: DevSession, changedPath: string):
     await requestRestart(session);
 };
 
+const restartForFont = async (session: DevSession, changedPath: string): Promise<void> => {
+    session.deps.log(`Font import added: ${changedPath}`);
+    await requestRestart(session);
+};
+
 const restartForCatalog = async (session: DevSession, changedPath: string): Promise<void> => {
     if (session.deps.hasWrittenCatalog(changedPath)) {
         return;
@@ -380,20 +386,32 @@ const restartForCatalog = async (session: DevSession, changedPath: string): Prom
     await requestRestart(session);
 };
 
-const applyChange = async (session: DevSession, change: WatchedChange): Promise<void> => {
-    if (session.controller.isShuttingDown()) {
-        return;
-    }
+const didRestartForChange = async (session: DevSession, change: WatchedChange): Promise<boolean> => {
+    const { root } = session.server.config;
 
-    if (isCatalogSource(session.server.config.root, change.path)) {
+    if (isCatalogSource(root, change.path)) {
         await restartForCatalog(session, change.path);
 
-        return;
+        return true;
     }
 
     if (isServerConfigFile(session.server.config, change.path)) {
         await restartForServerConfig(session, change.path);
 
+        return true;
+    }
+
+    if (change.event !== "unlink" && hasUnstagedFontImport(root, change.path)) {
+        await restartForFont(session, change.path);
+
+        return true;
+    }
+
+    return false;
+};
+
+const applyChange = async (session: DevSession, change: WatchedChange): Promise<void> => {
+    if (session.controller.isShuttingDown() || await didRestartForChange(session, change)) {
         return;
     }
 

package/src/internal/agent-rules.ts

@@ -18,9 +18,13 @@ const TOP_LEVEL_HEADING = /^# /m;
 const rulesBody = (heading: string): string[] => [
     `${heading} GTKX`,
     "",
-    "This is not the GTK you have seen before. Most GTK code in your training data is C, PyGObject, Vala or " +
-    "GJS, and almost none of it is valid here. Check the rules below against what you are about to write.",
+    "GTKX applications are Adwaita-first, with GTK4 underneath. Most GNOME UI code in your training data is C, " +
+    "PyGObject, Vala or GJS, and almost none of it is valid here. Check the rules below against what you are " +
+    "about to write.",
     "",
+    "- Start application shells with `AdwApplication` and `AdwApplicationWindow`. Freeform windows normally use " +
+    "`AdwToolbarView` and `AdwHeaderBar`; navigation containers own their Adwaita chrome. Prefer Adwaita for " +
+    "structure, navigation, dialogs, rows, and adaptive patterns; use GTK4 for lower-level primitives.",
     "- Children are JSX, never `.append()`, `pack_start()`, `set_child()` or `add()`.",
     '- Signals are props: `onClicked`, not `widget.connect("clicked", ...)`.',
     "- Props are camelCase: `marginTop`, not `margin-top` or `margin_top`.",

package/src/internal/banner.ts

@@ -15,6 +15,10 @@ const prependBanner = (options: Rollup.OutputOptions, banner: Banner): Rollup.Ou
             const prefix = await renderBanner(banner, chunk);
             const suffix = existing === undefined ? "" : await renderBanner(existing, chunk);
 
+            if (prefix.length === 0) {
+                return suffix;
+            }
+
             return suffix.length === 0 ? prefix : `${prefix}\n${suffix}`;
         },
     };

package/src/internal/font-path.ts

@@ -0,0 +1,15 @@
+import { createHash } from "node:crypto";
+import { basename, extname } from "node:path";
+
+const FONTS_DIR = "fonts";
+const DIGEST_LENGTH = 8;
+
+const fontFileName = (sourcePath: string, content: Buffer): string => {
+    const extension = extname(sourcePath).toLowerCase();
+    const stem = basename(sourcePath, extname(sourcePath));
+    const digest = createHash("sha1").update(content).digest("hex").slice(0, DIGEST_LENGTH);
+
+    return `${stem}-${digest}${extension}`;
+};
+
+export { fontFileName, FONTS_DIR };

package/src/internal/font-staging.ts

@@ -0,0 +1,129 @@
+import { sortStrings } from "@gtkx/utils";
+import { lstatSync, mkdirSync, readFileSync, symlinkSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { parseFontSpecifier } from "../vite-plugins/asset-specifier.js";
+import { fontFileName, FONTS_DIR } from "./font-path.js";
+import { discoverSourceImports, type SourceImport, sourceLanguage } from "./source-imports.js";
+import { createRetainedStagingDir } from "./staging-dir.js";
+
+type FontStagingStatus = "absent" | "staged" | "unmanaged";
+
+const FONT_DIR_ENV = "GTKX_DEV_FONT_DIR";
+const FONT_QUERY = "?font";
+const fontStaging = createRetainedStagingDir("fonts");
+
+const isRelativeImport = (source: string): boolean => source.startsWith("./") || source.startsWith("../");
+
+const existingPath = (path: string): string | null =>
+    lstatSync(path, { throwIfNoEntry: false }) === undefined ? null : path;
+
+const resolveRelativeImport = (importer: string, assetSource: string): string | null =>
+    existingPath(resolve(dirname(importer), assetSource));
+
+const resolveAbsoluteImport = (root: string, assetSource: string): string | null =>
+    existingPath(assetSource) ?? existingPath(join(root, assetSource));
+
+const resolvePackageImport = (importer: string, assetSource: string): string | null => {
+    try {
+        return createRequire(importer).resolve(assetSource);
+    } catch {
+        return null;
+    }
+};
+
+const resolveFontImport = (root: string, importer: string, assetSource: string): string | null => {
+    if (isRelativeImport(assetSource)) {
+        return resolveRelativeImport(importer, assetSource);
+    }
+
+    if (isAbsolute(assetSource)) {
+        return resolveAbsoluteImport(root, assetSource);
+    }
+
+    return resolvePackageImport(importer, assetSource);
+};
+
+const fontFileFor = (root: string, { importer, source }: SourceImport): string | null => {
+    const specifier = parseFontSpecifier(source);
+
+    return specifier === null ? null : resolveFontImport(root, importer, specifier.assetSource);
+};
+
+const projectFontFiles = (root: string): string[] => {
+    const files = discoverSourceImports(root)
+        .map((entry) => fontFileFor(root, entry))
+        .filter((path): path is string => path !== null);
+
+    return sortStrings(new Set(files));
+};
+
+const stagedPath = (fontsDir: string, sourcePath: string, content: Buffer): string =>
+    join(fontsDir, fontFileName(sourcePath, content));
+
+const stageFont = (fontsDir: string, sourcePath: string): void => {
+    const target = stagedPath(fontsDir, sourcePath, readFileSync(sourcePath));
+
+    if (existingPath(target) !== null) {
+        return;
+    }
+
+    symlinkSync(sourcePath, target, "file");
+};
+
+const stagedFontsDir = (): string | null => {
+    const shareDir = process.env[FONT_DIR_ENV];
+
+    return shareDir === undefined || shareDir.length === 0 ? null : join(shareDir, FONTS_DIR);
+};
+
+const stagedFontStatus = (sourcePath: string, content: Buffer): FontStagingStatus => {
+    const fontsDir = stagedFontsDir();
+
+    if (fontsDir === null) {
+        return "unmanaged";
+    }
+
+    return existingPath(stagedPath(fontsDir, sourcePath, content)) === null ? "absent" : "staged";
+};
+
+const hasFontImportMention = (filePath: string): boolean => {
+    if (sourceLanguage(filePath) === undefined) {
+        return false;
+    }
+
+    try {
+        return readFileSync(filePath, "utf8").includes(FONT_QUERY);
+    } catch {
+        return false;
+    }
+};
+
+const isUnstagedFont = (fontsDir: string, sourcePath: string): boolean =>
+    existingPath(stagedPath(fontsDir, sourcePath, readFileSync(sourcePath))) === null;
+
+const hasUnstagedFontImport = (root: string, filePath: string): boolean => {
+    const fontsDir = stagedFontsDir();
+
+    if (fontsDir === null || !hasFontImportMention(filePath)) {
+        return false;
+    }
+
+    return projectFontFiles(root).some((sourcePath) => isUnstagedFont(fontsDir, sourcePath));
+};
+
+const stageProjectFonts = (root: string): string => {
+    const shareDir = fontStaging.retain();
+    const fontsDir = join(shareDir, FONTS_DIR);
+    mkdirSync(fontsDir, { recursive: true });
+
+    for (const sourcePath of projectFontFiles(root)) {
+        stageFont(fontsDir, sourcePath);
+    }
+
+    process.env[FONT_DIR_ENV] = shareDir;
+
+    return shareDir;
+};
+
+export { hasUnstagedFontImport, stagedFontStatus, stageProjectFonts };

package/src/internal/source-imports.ts

@@ -1,6 +1,6 @@
 import type { ESTree, ParseResult, ParserOptions } from "vite";
 import { sortStringsBy } from "@gtkx/utils";
-import { globSync, readFileSync } from "node:fs";
+import { existsSync, globSync, readFileSync } from "node:fs";
 import { extname, join } from "node:path";
 import { parseSync, Visitor } from "vite";
 
@@ -29,11 +29,19 @@ const sourceLanguage = (path: string): SourceLanguage | undefined => {
     return SOURCE_LANGUAGES.get(extname(path).toLowerCase());
 };
 
+const SOURCE_DIR = "src";
+
+const sourceDirFor = (root: string): string => {
+    const sourceDir = join(root, SOURCE_DIR);
+
+    return existsSync(sourceDir) ? sourceDir : root;
+};
+
 const discoverSourceFiles = (dir: string): string[] =>
     sortStringsBy(
         globSync("**/{*,.*}", {
             cwd: dir,
-            exclude: ["**/{build,coverage,dist,node_modules,out-tsc}/**", "**/.gtkx-output-*/**"],
+            exclude: ["**/{build,coverage,dist,node_modules,out-tsc}/**", "**/.gtkx-output-*/**", "**/.git/**"],
             withFileTypes: true,
         })
             .filter((entry) => entry.isFile())
@@ -132,4 +140,11 @@ const discoverSourceImports = (dir: string): SourceImport[] => {
     return sortStringsBy(imports, importKey);
 };
 
-export { discoverSourceFiles, discoverSourceImports, parseRuntimeImportsIn, type SourceImport, sourceLanguage };
+export {
+    discoverSourceFiles,
+    discoverSourceImports,
+    parseRuntimeImportsIn,
+    sourceDirFor,
+    sourceLanguage,
+    type SourceImport,
+};

package/src/internal/xdg-banner.ts

@@ -0,0 +1,13 @@
+import type { Rollup } from "vite";
+import { outputRootUrlExpression } from "./banner.js";
+import { XDG_DATA_DIRS_DEFAULT } from "./xdg-data-dirs.js";
+
+const xdgDataDirsBanner = (chunk: Rollup.RenderedChunk): string => [
+    "globalThis.process.env.XDG_DATA_DIRS = (() => {",
+    `    const root = ${outputRootUrlExpression(chunk)};`,
+    `    const dirs = globalThis.process.env.XDG_DATA_DIRS || ${JSON.stringify(XDG_DATA_DIRS_DEFAULT)};`,
+    "    return dirs.split(\":\").includes(root) ? dirs : `${root}:${dirs}`;",
+    "})();",
+].join("\n");
+
+export { xdgDataDirsBanner };

package/src/internal/xdg-data-dirs.ts

@@ -10,4 +10,4 @@ const prependXdgDataDir = (dir: string, existing: string | undefined): string =>
     return `${dir}:${base}`;
 };
 
-export { prependXdgDataDir };
+export { prependXdgDataDir, XDG_DATA_DIRS_DEFAULT };

package/src/settings/schema.ts

@@ -12,7 +12,7 @@ import {
 import { tmpdir } from "node:os";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { I18N_TYPES_FILENAME, i18nTypesPath } from "../i18n/types.js";
-import { discoverSourceImports, type SourceImport } from "../internal/source-imports.js";
+import { discoverSourceImports, sourceDirFor, type SourceImport } from "../internal/source-imports.js";
 import { removeTempDir } from "../internal/staging-dir.js";
 import {
     isBareRelativeAsset,
@@ -30,7 +30,6 @@ type SchemaEnvResult = {
 
 const SCHEMA_SUFFIX = ".gschema.xml";
 const STAGED_NAME_LENGTH = 16;
-const SOURCE_DIR = "src";
 const RESOURCE_QUERY = "?resource=";
 const ICON_QUERY = "?icon=";
 
@@ -69,12 +68,6 @@ const projectRelativeSchemaPath = (root: string, filePath: string): string | nul
 
 const getRelativeModuleSpecifier = (filePath: string): string => `*/${basename(filePath)}`;
 
-const sourceDirFor = (root: string): string => {
-    const sourceDir = join(root, SOURCE_DIR);
-
-    return existsSync(sourceDir) ? sourceDir : root;
-};
-
 const isRelativeImport = (source: string): boolean => source.startsWith("./") || source.startsWith("../");
 
 const schemaFileFor = ({ importer, source }: SourceImport): string | null =>

package/src/vite-plugins/asset-extensions.ts

@@ -18,6 +18,8 @@ const ASSET_EXTENSIONS = [
     "eot",
     "ttf",
     "otf",
+    "ttc",
+    "otc",
     "ico",
     "avif",
     "data",

package/src/vite-plugins/asset-imports.ts

@@ -5,6 +5,7 @@ import { ASSET_MENTION_RE } from "./asset-extensions.js";
 import {
     isAssetSpecifier,
     isUrlSpecifier,
+    parseFontSpecifier,
     parseIconSpecifier,
     parseResourceSpecifier,
 } from "./asset-specifier.js";
@@ -31,8 +32,11 @@ const RESOURCE_ADVICE =
 
 const ICON_ADVICE = "An icon asset exports only its default icon-theme name, and nothing else.";
 
+const FONT_ADVICE = "A font asset exports only its default font family name, and nothing else.";
+
 const RELATIVE_ADVICE =
-    "Add ?resource for a GResource, ?icon for a themed icon, or ?url for an emitted file.";
+    "Add ?resource for a GResource, ?icon for a themed icon, ?font for a bundled font, or ?url for an " +
+    "emitted file.";
 
 const boundName = (entry: BindingEntry): string | null => {
     const { name } = entry.importName;
@@ -87,6 +91,10 @@ const adviceFor = (source: string): string => {
         return ICON_ADVICE;
     }
 
+    if (parseFontSpecifier(source) !== null) {
+        return FONT_ADVICE;
+    }
+
     if (isUrlSpecifier(source)) {
         return QUERY_ADVICE;
     }

package/src/vite-plugins/asset-specifier.ts

@@ -11,9 +11,14 @@ type IconSpecifier = {
     iconName: string | null;
 };
 
+type FontSpecifier = {
+    assetSource: string;
+};
+
 const RELATIVE_PREFIX_RE = /^\.\.?(?:\/|$)/;
 const RESOURCE_QUERY_RE = /^resource(?:=([^&#]+))?$/;
 const ICON_QUERY_RE = /^icon(?:=([^&#]+))?$/;
+const FONT_QUERY_RE = /^font$/;
 const URL_QUERY_RE = /(?:^|&)url(?:&|$)/;
 
 const getQuery = (source: string): string | null => {
@@ -61,6 +66,17 @@ const parseIconSpecifier = (source: string): IconSpecifier | null => {
     return { assetSource, iconName: match[1] ?? null };
 };
 
+const parseFontSpecifier = (source: string): FontSpecifier | null => {
+    const query = getQuery(source);
+    const assetSource = stripQuery(source);
+
+    if (query === null || !ASSET_RE.test(assetSource) || !FONT_QUERY_RE.test(query)) {
+        return null;
+    }
+
+    return { assetSource };
+};
+
 const isUrlSpecifier = (source: string): boolean => {
     const query = getQuery(source);
 
@@ -71,6 +87,7 @@ export {
     isAssetSpecifier,
     isBareRelativeAsset,
     isUrlSpecifier,
+    parseFontSpecifier,
     parseIconSpecifier,
     parseResourceSpecifier,
 };

package/src/vite-plugins/css.ts

@@ -4,6 +4,7 @@ import { createVirtualNamespace } from "./virtual-module.js";
 
 type CssResolveContext = Parameters<typeof resolveToVirtual>[0];
 type CssResolveRequest = Parameters<typeof resolveToVirtual>[1];
+type CssLoadContext = { addWatchFile: (file: string) => void };
 
 const CSS_RE = /\.css$/i;
 const INJECT_SUFFIX = "?inject";
@@ -24,13 +25,14 @@ const resolveCssId = async (ctx: CssResolveContext, request: CssResolveRequest):
     return virtualId + INJECT_SUFFIX;
 };
 
-const loadInjectedCss = (id: string): string | undefined => {
+const loadInjectedCss = (ctx: CssLoadContext, 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");
+    ctx.addWatchFile(filePath);
 
     return ["import { injectGlobal } from \"@gtkx/css\";", `injectGlobal(${JSON.stringify(content)});`].join("\n");
 };
@@ -45,7 +47,7 @@ function gtkxCss(): Plugin {
         },
 
         load(id) {
-            return loadInjectedCss(id);
+            return loadInjectedCss(this, id);
         },
     };
 }