@gtkx/cli 1.0.0-rc.1 → 1.0.0-rc.2

package/src/vite-plugins/settings.ts

@@ -1,8 +1,8 @@
+import type { ModuleNode, Plugin, ResolvedConfig, UserConfig, ViteDevServer } from "vite";
+import { error, errorMessage, info } from "@gtkx/utils";
 import { mkdtempSync, readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
-import { error, errorMessage, info } from "@gtkx/utils";
-import type { ModuleNode, Plugin, UserConfig, ViteDevServer } from "vite";
 import { prependBanner } from "../internal/banner.js";
 import { resolveDataDir } from "../internal/data-dir.js";
 import { removeTempDir, withStagingDir } from "../internal/staging-dir.js";
@@ -12,18 +12,6 @@ import { renderRuntimeModule } from "../settings/render.js";
 import { emitSchemaEnv, prependSchemaDir, SCHEMA_SUFFIX, stageSchema } from "../settings/schema.js";
 import { createVirtualNamespace } from "./virtual-module.js";
 
-const VIRTUAL_PREFIX = "\0gtkx-settings:";
-const { isVirtual, fromVirtualId, resolveToVirtual } = createVirtualNamespace(VIRTUAL_PREFIX);
-
-const SCHEMA_ENV_BANNER = [
-    `process.env.GSETTINGS_SCHEMA_DIR = [`,
-    `    decodeURIComponent(new URL(".", import.meta.url).pathname),`,
-    `    process.env.GSETTINGS_SCHEMA_DIR,`,
-    `]`,
-    `    .filter(Boolean)`,
-    `    .join(":");`,
-].join("\n");
-
 type PluginState = {
     schemaDir: string | null;
     rootDir: string | null;
@@ -39,54 +27,97 @@ type PluginContext = {
     emitFile: (file: { type: "asset"; fileName: string; source: Buffer }) => void;
 };
 
+const VIRTUAL_PREFIX = "\0gtkx-settings:";
+const { isVirtual, fromVirtualId, resolveToVirtual } = createVirtualNamespace(VIRTUAL_PREFIX);
+
+const SCHEMA_ENV_BANNER = [
+    "process.env.GSETTINGS_SCHEMA_DIR = [",
+    "    decodeURIComponent(new URL(\".\", import.meta.url).pathname),",
+    "    process.env.GSETTINGS_SCHEMA_DIR,",
+    "]",
+    "    .filter(Boolean)",
+    "    .join(\":\");",
+].join("\n");
+
 const ensureSchemaDir = (state: PluginState): string => {
     if (!state.schemaDir) {
         const runnerDir = process.env.GTKX_DEV_SCHEMA_DIR;
+
         if (runnerDir) {
             state.schemaDir = runnerDir;
+
             return runnerDir;
         }
+
         const dir = mkdtempSync(join(tmpdir(), "gtkx-schemas-"));
         state.schemaDir = dir;
-        const cleanup = (): void => removeTempDir(dir);
+
+        const cleanup = (): void => {
+            removeTempDir(dir);
+        };
+
         state.cleanupProcessExit = cleanup;
         process.once("exit", cleanup);
     }
+
     return state.schemaDir;
 };
 
 const releaseSchemaDir = (state: PluginState): void => {
-    if (!state.schemaDir) return;
+    if (!state.schemaDir) {
+        return;
+    }
+
     if (state.cleanupProcessExit) {
         removeTempDir(state.schemaDir);
         process.removeListener("exit", state.cleanupProcessExit);
         state.cleanupProcessExit = null;
     }
+
     state.schemaDir = null;
 };
 
 const compileSchemaDir = (state: PluginState): void => {
-    if (!state.schemaDir) return;
+    if (!state.schemaDir) {
+        return;
+    }
+
     compileSchemas(state.schemaDir);
     process.env.GSETTINGS_SCHEMA_DIR = prependSchemaDir(state.schemaDir, process.env.GSETTINGS_SCHEMA_DIR);
 };
 
 const syncSchemaEnv = (state: PluginState): void => {
-    if (state.rootDir === null) return;
+    if (state.rootDir === null) {
+        return;
+    }
+
     try {
         emitSchemaEnv(state.rootDir, state.dataDir);
-    } catch (cause) {
-        error(`Failed to generate GSettings schema types: ${errorMessage(cause)}`);
+    } catch (error_) {
+        error(`Failed to generate GSettings schema types: ${errorMessage(error_)}`);
     }
 };
 
+const applyUserConfig = (state: PluginState, config: UserConfig): void => {
+    state.dataDir = resolveDataDir(config.root ?? process.cwd());
+};
+
+const applyResolvedConfig = (state: PluginState, config: ResolvedConfig): void => {
+    state.isBuild = config.command === "build";
+    state.rootDir = typeof config.root === "string" ? config.root : null;
+    syncSchemaEnv(state);
+};
+
 const registerSchemaForMode = (state: PluginState, filePath: string, id: string): void => {
     const fileName = basename(filePath);
+
     if (state.isBuild) {
         state.buildSchemas.add(filePath);
         info(`Queued GSettings schema: ${fileName}`);
+
         return;
     }
+
     state.trackedSchemas.set(filePath, id);
     const dir = ensureSchemaDir(state);
     stageSchema(dir, filePath);
@@ -94,74 +125,104 @@ const registerSchemaForMode = (state: PluginState, filePath: string, id: string)
     info(`Compiled GSettings schema: ${fileName}`);
 };
 
-const loadSchemaModule = (ctx: PluginContext, state: PluginState, id: string): string => {
+const loadSchemaModule = (ctx: PluginContext, state: PluginState, id: string): string | undefined => {
+    if (!isVirtual(id)) {
+        return undefined;
+    }
+
     const filePath = fromVirtualId(id);
-    const xml = readFileSync(filePath, "utf-8");
+    const xml = readFileSync(filePath, "utf8");
     const fileName = basename(filePath);
-
     registerSchemaForMode(state, filePath, id);
-
     let parsed: ReturnType<typeof parseSchemaXml>;
+
     try {
         parsed = parseSchemaXml(xml, fileName);
     } catch (error) {
-        if (!(error instanceof SchemaParseError)) throw error;
+        if (!(error instanceof SchemaParseError)) {
+            throw error;
+        }
+
         ctx.error(error.message);
     }
+
     if (parsed.schemas.length === 0) {
         ctx.error(`No <schema id="..."> found in ${fileName}`);
     }
+
     return renderRuntimeModule(parsed);
 };
 
 const emitCompiledSchemas = (ctx: PluginContext, state: PluginState): void => {
-    if (!state.isBuild || state.buildSchemas.size === 0) return;
+    if (!state.isBuild || state.buildSchemas.size === 0) {
+        return;
+    }
 
     const compiled = withStagingDir("schemas-build", (dir) => {
         for (const filePath of state.buildSchemas) {
             stageSchema(dir, filePath);
         }
+
         compileSchemas(dir);
+
         return readFileSync(join(dir, "gschemas.compiled"));
     });
+
     ctx.emitFile({
         type: "asset",
         fileName: "gschemas.compiled",
         source: compiled,
     });
 
-    info(`Compiled ${state.buildSchemas.size} GSettings schema(s)`);
+    info(`Compiled ${String(state.buildSchemas.size)} GSettings schema(s)`);
 };
 
 const handleSchemaHotUpdate = (state: PluginState, file: string, server: ViteDevServer): ModuleNode[] | undefined => {
+    if (file.endsWith(SCHEMA_SUFFIX)) {
+        syncSchemaEnv(state);
+    }
+
     const virtualId = state.trackedSchemas.get(file);
-    if (!virtualId) return;
+
+    if (!virtualId) {
+        return;
+    }
 
     const dir = ensureSchemaDir(state);
     stageSchema(dir, file);
     compileSchemaDir(state);
-
     info(`Recompiled GSettings schema: ${basename(file)}`);
-
     const mod = server.moduleGraph.getModuleById(virtualId);
+
     if (mod) {
         server.moduleGraph.invalidateModule(mod);
+
         return [mod];
     }
+
     return undefined;
 };
 
 const watchSchemaFiles = (state: PluginState, server: ViteDevServer): void => {
-    server.httpServer?.once("close", () => releaseSchemaDir(state));
-    server.watcher.once("close", () => releaseSchemaDir(state));
+    server.httpServer?.once("close", () => {
+        releaseSchemaDir(state);
+    });
+
+    server.watcher.once("close", () => {
+        releaseSchemaDir(state);
+    });
+
     const refreshSchemaTypes = (file: string): void => {
-        if (file.endsWith(SCHEMA_SUFFIX)) syncSchemaEnv(state);
+        if (file.endsWith(SCHEMA_SUFFIX)) {
+            syncSchemaEnv(state);
+        }
     };
+
     server.watcher.on("add", refreshSchemaTypes);
     server.watcher.on("unlink", refreshSchemaTypes);
 };
 
-export function gtkxSettings(): Plugin {
+function gtkxSettings(): Plugin {
     const state: PluginState = {
         schemaDir: null,
         rootDir: null,
@@ -177,13 +238,11 @@ export function gtkxSettings(): Plugin {
         enforce: "pre",
 
         config(config: UserConfig) {
-            state.dataDir = resolveDataDir(config.root ?? process.cwd());
+            applyUserConfig(state, config);
         },
 
         configResolved(config) {
-            state.isBuild = config.command === "build";
-            state.rootDir = typeof config.root === "string" ? config.root : null;
-            syncSchemaEnv(state);
+            applyResolvedConfig(state, config);
         },
 
         configureServer(server) {
@@ -191,17 +250,22 @@ export function gtkxSettings(): Plugin {
         },
 
         outputOptions(options) {
-            if (!state.isBuild) return;
+            if (!state.isBuild) {
+                return;
+            }
+
             return prependBanner(options, SCHEMA_ENV_BANNER);
         },
 
         async resolveId(source, importer, options) {
-            if (!source.endsWith(SCHEMA_SUFFIX)) return;
+            if (!source.endsWith(SCHEMA_SUFFIX)) {
+                return;
+            }
+
             return resolveToVirtual(this, { source, importer, options });
         },
 
         load(id) {
-            if (!isVirtual(id)) return;
             return loadSchemaModule(this, state, id);
         },
 
@@ -214,8 +278,9 @@ export function gtkxSettings(): Plugin {
         },
 
         handleHotUpdate({ file, server }) {
-            if (file.endsWith(SCHEMA_SUFFIX)) syncSchemaEnv(state);
             return handleSchemaHotUpdate(state, file, server);
         },
     };
 }
+
+export { gtkxSettings };

package/src/vite-plugins/strip-query.ts

@@ -0,0 +1,7 @@
+const stripQuery = (source: string): string => {
+    const queryIndex = source.indexOf("?");
+
+    return queryIndex === -1 ? source : source.slice(0, queryIndex);
+};
+
+export { stripQuery };

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

@@ -1,8 +1,6 @@
+import type { Plugin, UserConfig } from "vite";
 import { discoverGirNamespaces, resolveGirPath } from "@gtkx/codegen";
 import { loadConfig } from "@gtkx/config";
-import type { Plugin, UserConfig } from "vite";
-
-const GENERATED_MODULE_PATTERN = /^@gtkx\/(?:gi|jsx)\/([a-z0-9]+)$/;
 
 type PluginState = {
     root: string;
@@ -10,18 +8,21 @@ type PluginState = {
     girPath: string[] | null;
 };
 
+const GENERATED_MODULE_PATTERN = /^@gtkx\/(?:gi|jsx)\/([a-z0-9]+)$/;
+
 const girSearchPaths = async (state: PluginState): Promise<string[]> => {
     if (state.girPath === null) {
         const { config } = await loadConfig(state.root, { mode: state.mode });
         state.girPath = resolveGirPath(config.girPath);
     }
+
     return state.girPath;
 };
 
-const namespaceOf = (identifier: string): string => identifier.slice(0, identifier.indexOf("-")).toLowerCase();
+const getNamespace = (identifier: string): string => identifier.slice(0, identifier.indexOf("-")).toLowerCase();
 
 const findGirIdentifier = (girPath: string[], namespace: string): string | undefined =>
-    discoverGirNamespaces(girPath).find((identifier) => namespaceOf(identifier) === namespace);
+    discoverGirNamespaces(girPath).find((identifier) => getNamespace(identifier) === namespace);
 
 const undeclaredLibraryError = (source: string, namespace: string, girPath: string[]): Error => {
     const identifier = findGirIdentifier(girPath, namespace);
@@ -29,19 +30,19 @@ const undeclaredLibraryError = (source: string, namespace: string, girPath: stri
     if (identifier === undefined) {
         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 and add its GIR identifier to `libraries` in gtkx.config.ts. " +
-                "Otherwise run gtkx codegen to regenerate the store.",
+            `was found in [${girPath.join(", ")}]. If "${namespace}" is a library, install its ` +
+            "gobject-introspection data package and add its GIR identifier to `libraries` in gtkx.config.ts. " +
+            "Otherwise run gtkx codegen to regenerate the store.",
         );
     }
 
     return new Error(
         `Cannot resolve "${source}": the "${identifier}" bindings have not been generated. ` +
-            `Add "${identifier}" to \`libraries\` in gtkx.config.ts, then run gtkx dev or gtkx build again.`,
+        `Add "${identifier}" to \`libraries\` in gtkx.config.ts, then run gtkx dev or gtkx build again.`,
     );
 };
 
-export function gtkxUndeclaredLibrary(mode?: string): Plugin {
+function gtkxUndeclaredLibrary(mode?: string): Plugin {
     const state: PluginState = {
         root: "",
         mode,
@@ -58,12 +59,20 @@ export function gtkxUndeclaredLibrary(mode?: string): Plugin {
 
         async resolveId(source, importer, options) {
             const namespace = GENERATED_MODULE_PATTERN.exec(source)?.[1];
-            if (namespace === undefined) return;
+
+            if (namespace === undefined) {
+                return;
+            }
 
             const resolved = await this.resolve(source, importer, { ...options, skipSelf: true });
-            if (resolved !== null) return;
+
+            if (resolved !== null) {
+                return;
+            }
 
             throw undeclaredLibraryError(source, namespace, await girSearchPaths(state));
         },
     };
 }
+
+export { gtkxUndeclaredLibrary };

package/src/vite-plugins/virtual-module.ts

@@ -19,8 +19,9 @@ type VirtualNamespace = {
     resolveToVirtual: (ctx: VirtualResolveContext, request: VirtualResolveRequest) => Promise<string | undefined>;
 };
 
-export const createVirtualNamespace = (prefix: string): VirtualNamespace => {
+const createVirtualNamespace = (prefix: string): VirtualNamespace => {
     const toVirtualId = (realId: string): string => prefix + realId;
+
     return {
         isVirtual: (id) => id.startsWith(prefix),
         toVirtualId,
@@ -30,8 +31,14 @@ export const createVirtualNamespace = (prefix: string): VirtualNamespace => {
                 ...request.options,
                 skipSelf: true,
             });
-            if (!resolved || resolved.external) return undefined;
+
+            if (!resolved || resolved.external) {
+                return;
+            }
+
             return toVirtualId(resolved.id);
         },
     };
 };
+
+export { createVirtualNamespace };

package/src/vitest-plugin.ts

@@ -1,5 +1,5 @@
-import gtkxVitest from "@gtkx/vitest";
 import type { Plugin } from "vite";
+import gtkxVitest from "@gtkx/vitest";
 import { gtkxVitePlugins } from "./vite-plugins/index.js";
 import { gtkxSettingsWorkerEnv } from "./vite-plugins/settings-worker-env.js";
 
@@ -10,5 +10,4 @@ import { gtkxSettingsWorkerEnv } from "./vite-plugins/settings-worker-env.js";
  * @returns The ordered array of Vite plugins to include in a Vitest configuration.
  */
 const gtkx = (): Plugin[] => [...gtkxVitePlugins(), gtkxSettingsWorkerEnv(), gtkxVitest()];
-
 export default gtkx;