@gtkx/cli 2.0.0-beta.1 → 2.0.0-beta.10

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,13 +12,17 @@ function gtkxStoreLinks(): Plugin {
         enforce: "pre",
 
         config(config: UserConfig) {
-            state.root = config.root ?? process.cwd();
+            state.root = viteProjectRoot(config);
         },
 
-        resolveId(source) {
-            if (GENERATED_MODULE_PREFIX.test(source)) {
-                ensureStoreLinks(state.root);
-            }
+        resolveId: {
+            filter: { id: GENERATED_MODULE_PREFIX },
+
+            handler(source) {
+                if (GENERATED_MODULE_PREFIX.test(source)) {
+                    ensureStoreLinks(state.root);
+                }
+            },
         },
     };
 }

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,23 +129,27 @@ 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) {
-            const generated = parseGeneratedModule(source, importer);
+        resolveId: {
+            filter: { id: GENERATED_MODULE_PATTERN },
 
-            if (generated === null) {
-                return;
-            }
+            async handler(source, importer, options) {
+                const generated = parseGeneratedModule(source, importer);
 
-            const resolved = await this.resolve(source, importer, { ...options, skipSelf: true });
+                if (generated === null) {
+                    return;
+                }
 
-            if (resolved !== null) {
-                return;
-            }
+                const resolved = await this.resolve(source, importer, { ...options, skipSelf: true });
 
-            throw await unresolvedModuleError(state, generated);
+                if (resolved !== null) {
+                    return;
+                }
+
+                throw await unresolvedModuleError(state, generated);
+            },
         },
     };
 }

package/src/vite-plugins/worker.ts

@@ -7,12 +7,17 @@ import { stripQuery } from "./strip-query.js";
 type WorkerReplacement = {
     start: number;
     end: number;
-    fileName: string;
+    referenceId: string;
+};
+
+type WorkerReferences = {
+    byModule: Map<string, string>;
+    claimed: Set<string>;
 };
 
 type EmitContext = {
     context: Rollup.PluginContext;
-    emitted: Map<string, string>;
+    references: WorkerReferences;
 };
 
 type SourceRange = {
@@ -83,10 +88,12 @@ const isWorkerConstruction = (code: string, matchIndex: number): boolean =>
 
 const hasWorkerCandidate = (code: string): boolean => code.includes("import.meta.url") && code.includes("Worker");
 
-const workerUrlExpression = (fileName: string): string => {
-    const specifier = JSON.stringify(`./${fileName}`);
+const workerUrlReference = (referenceId: string): string => `import.meta.ROLLUP_FILE_URL_${referenceId}`;
+
+const workerUrlExpression = (relativePath: string): string => {
+    const specifier = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
 
-    return `new URL(${specifier}, import.meta.url)`;
+    return `new URL(${JSON.stringify(specifier)}, import.meta.url)`;
 };
 
 const inlineWorkerExample = (specifier: string): string =>
@@ -125,17 +132,22 @@ const suggestionFor = async (emit: EmitContext, scan: ScanContext, specifier: st
 };
 
 const claimWorker = (emit: EmitContext, resolvedId: string): string => {
-    const existing = emit.emitted.get(resolvedId);
+    const existing = emit.references.byModule.get(resolvedId);
 
     if (existing !== undefined) {
         return existing;
     }
 
-    const fileName = workerFileName(resolvedId);
-    emit.emitted.set(resolvedId, fileName);
-    emit.context.emitFile({ type: "chunk", id: resolvedId, fileName });
+    const referenceId = emit.context.emitFile({
+        type: "chunk",
+        id: resolvedId,
+        fileName: workerFileName(resolvedId),
+    });
 
-    return fileName;
+    emit.references.byModule.set(resolvedId, referenceId);
+    emit.references.claimed.add(referenceId);
+
+    return referenceId;
 };
 
 const isRewritableUrl = (scan: ScanContext, match: RegExpExecArray): boolean =>
@@ -158,7 +170,7 @@ const replacementFor = async (
         throw unresolvedWorkerError(scan, specifier, await suggestionFor(emit, scan, specifier));
     }
 
-    return { start: match.index, end: match.index + match[0].length, fileName: claimWorker(emit, resolved.id) };
+    return { start: match.index, end: match.index + match[0].length, referenceId: claimWorker(emit, resolved.id) };
 };
 
 const collectReplacements = async (emit: EmitContext, scan: ScanContext): Promise<WorkerReplacement[]> => {
@@ -196,8 +208,8 @@ const applyReplacements = (code: string, replacements: WorkerReplacement[]): str
     let output = "";
     let cursor = 0;
 
-    for (const { start, end, fileName } of replacements) {
-        output += code.slice(cursor, start) + workerUrlExpression(fileName);
+    for (const { start, end, referenceId } of replacements) {
+        output += code.slice(cursor, start) + workerUrlReference(referenceId);
         cursor = end;
     }
 
@@ -222,14 +234,18 @@ const transformWorkerUrls = async (emit: EmitContext, code: string, id: string):
 };
 
 function gtkxWorker(): Plugin {
-    const emitted: Map<string, string> = new Map();
+    const references: WorkerReferences = { byModule: new Map(), claimed: new Set() };
 
     return {
         name: "gtkx:worker",
         apply: "build",
 
         transform(code, id) {
-            return transformWorkerUrls({ context: this, emitted }, code, id);
+            return transformWorkerUrls({ context: this, references }, code, id);
+        },
+
+        resolveFileUrl({ referenceId, relativePath }) {
+            return references.claimed.has(referenceId) ? workerUrlExpression(relativePath) : null;
         },
     };
 }

package/src/vitest-plugin.ts

@@ -1,21 +1,25 @@
 import type { Plugin } from "vite";
-import gtkxVitest from "@gtkx/vitest";
+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 { gtkxIconWorkerEnv } from "./vite-plugins/icon-worker-env.js";
 import { gtkxVitePlugins } from "./vite-plugins/index.js";
 import { gtkxSettingsWorkerEnv } from "./vite-plugins/settings-worker-env.js";
 
 /**
  * Vite plugin stack for testing a GTKX application: the generated bindings the tests import,
- * the plugins the app is built with, the project's compiled GSettings schemas exposed to every
- * test worker, and a headless display per worker.
+ * the plugins the app is built with, the project's compiled GSettings schemas and its configured
+ * application icon exposed to every test worker, and a headless display per worker.
  *
  * @returns The plugins to spread into a Vitest config.
  */
-const gtkx = (): Plugin[] => [
-    gtkxEnsureStore(),
-    ...gtkxVitePlugins(),
-    gtkxSettingsWorkerEnv(),
-    gtkxVitest(),
+const gtkx = (options: PluginOptions = {}): Plugin[] => [
+    gtkxEnsureStore(options.configFile),
+    ...gtkxVitePlugins({ configFile: options.configFile }),
+    gtkxSettingsWorkerEnv(options.configFile),
+    gtkxFontWorkerEnv(options.configFile),
+    gtkxIconWorkerEnv(options.configFile),
+    gtkxVitest(options),
 ];
 
 export default gtkx;