@gtkx/cli 1.0.0-rc.4 → 1.1.0

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

@@ -25,5 +25,6 @@ const ASSET_EXTENSIONS = [
 
 const ASSET_RE = new RegExp(String.raw`\.(?:${ASSET_EXTENSIONS.join("|")})$`, "i");
 const ASSET_PATH_RE = new RegExp(String.raw`\.(?:${ASSET_EXTENSIONS.join("|")})(?:\?.*)?$`, "i");
+const ASSET_MENTION_RE = new RegExp(String.raw`\.(?:${ASSET_EXTENSIONS.join("|")})`, "i");
 
-export { ASSET_EXTENSIONS, ASSET_RE, ASSET_PATH_RE };
+export { ASSET_MENTION_RE, ASSET_PATH_RE, ASSET_RE };

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

@@ -0,0 +1,134 @@
+import type { ParseResult, ParserOptions, Plugin } from "vite";
+import { extname } from "node:path";
+import { parseSync } from "vite";
+import { ASSET_MENTION_RE } from "./asset-extensions.js";
+import { DATA_PREFIX, isAssetSpecifier, isDataAsset } from "./asset-specifier.js";
+import { RESOURCE_PATH_EXPORT } from "./resource-shared.js";
+import { stripQuery } from "./strip-query.js";
+
+type SourceLanguage = NonNullable<ParserOptions["lang"]>;
+type ParsedModule = ParseResult["module"];
+type ImportStatement = ParsedModule["staticImports"][number];
+type ExportStatement = ParsedModule["staticExports"][number];
+type ExportEntry = ExportStatement["entries"][number];
+type BindingEntry = { importName: { name: string | null }; isType: boolean };
+type NamedBinding = { name: string; source: string };
+
+const SOURCE_LANGUAGES: Map<string, SourceLanguage> = new Map([
+    [".cjs", "jsx"],
+    [".cts", "ts"],
+    [".js", "jsx"],
+    [".jsx", "jsx"],
+    [".mjs", "jsx"],
+    [".mts", "ts"],
+    [".ts", "ts"],
+    [".tsx", "tsx"],
+]);
+
+const NODE_MODULES = /(?:^|\/)node_modules\//;
+const VIRTUAL_PREFIX = "\0";
+const DEFAULT_BINDING = "default";
+const RESOURCE_BINDING = JSON.stringify(RESOURCE_PATH_EXPORT);
+const DATA_IMPORT_EXAMPLE = `"${DATA_PREFIX}<path>"`;
+const URL_FALLBACK = ", or import the default for the asset URL.";
+
+const BUNDLE_ADVICE =
+    `An asset staged into the GResource bundle exports ${RESOURCE_BINDING} and a "resource://" default, and ` +
+    "nothing else.";
+
+const QUERY_ADVICE =
+    "A query suffix hands the import to the Vite asset pipeline instead of the GResource bundle; drop the " +
+    `query to keep ${RESOURCE_BINDING}${URL_FALLBACK}`;
+
+const RELATIVE_ADVICE =
+    `Only assets imported through "${DATA_PREFIX}" are staged into the GResource bundle and export ` +
+    `${RESOURCE_BINDING}; move the file under the data directory and import it as ` +
+    `${DATA_IMPORT_EXAMPLE}${URL_FALLBACK}`;
+
+const boundName = (entry: BindingEntry): string | null => {
+    const { name } = entry.importName;
+
+    if (name === null || name === DEFAULT_BINDING || entry.isType) {
+        return null;
+    }
+
+    return name;
+};
+
+const importBindings = (statement: ImportStatement): NamedBinding[] =>
+    statement.entries
+        .map((entry) => boundName(entry))
+        .filter((name) => name !== null)
+        .map((name) => ({ name, source: statement.moduleRequest.value }));
+
+const exportBinding = (entry: ExportEntry): NamedBinding | null => {
+    const name = boundName(entry);
+    const source = entry.moduleRequest?.value;
+
+    return name === null || source === undefined ? null : { name, source };
+};
+
+const exportBindings = (statement: ExportStatement): NamedBinding[] =>
+    statement.entries.map((entry) => exportBinding(entry)).filter((binding) => binding !== null);
+
+const bindings = (parsed: ParsedModule): NamedBinding[] => [
+    ...parsed.staticImports.flatMap((statement) => importBindings(statement)),
+    ...parsed.staticExports.flatMap((statement) => exportBindings(statement)),
+];
+
+const isBacked = ({ name, source }: NamedBinding): boolean =>
+    isDataAsset(source) && name === RESOURCE_PATH_EXPORT;
+
+const unbackedBinding = (parsed: ParsedModule): NamedBinding | undefined =>
+    bindings(parsed).find((binding) => isAssetSpecifier(binding.source) && !isBacked(binding));
+
+const bundleAdvice = (source: string): string => {
+    if (isDataAsset(source)) {
+        return BUNDLE_ADVICE;
+    }
+
+    return source.startsWith(DATA_PREFIX) ? QUERY_ADVICE : RELATIVE_ADVICE;
+};
+
+const unbackedBindingError = (path: string, binding: NamedBinding): Error =>
+    new Error(
+        `${path}: ${JSON.stringify(binding.source)} does not export ${JSON.stringify(binding.name)}, which ` +
+        "gtkx build rejects and gtkx dev would bind as undefined. " +
+        bundleAdvice(binding.source),
+    );
+
+const isCheckedSource = (path: string): boolean => !path.startsWith(VIRTUAL_PREFIX) && !NODE_MODULES.test(path);
+
+const checkAssetImports = (code: string, id: string): void => {
+    const path = stripQuery(id);
+    const lang = SOURCE_LANGUAGES.get(extname(path).toLowerCase());
+
+    if (lang === undefined || !isCheckedSource(path) || !ASSET_MENTION_RE.test(code)) {
+        return;
+    }
+
+    const parsed = parseSync(path, code, { lang });
+
+    if (parsed.errors.length > 0) {
+        return;
+    }
+
+    const binding = unbackedBinding(parsed.module);
+
+    if (binding !== undefined) {
+        throw unbackedBindingError(path, binding);
+    }
+};
+
+function gtkxAssetImports(): Plugin {
+    return {
+        name: "gtkx:asset-imports",
+        enforce: "pre",
+
+        transform(code, id) {
+            checkAssetImports(code, id);
+        },
+    };
+}
+
+export { gtkxAssetImports };

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

@@ -0,0 +1,9 @@
+import { DATA_IMPORT_PREFIX } from "../internal/data-dir.js";
+import { ASSET_PATH_RE, ASSET_RE } from "./asset-extensions.js";
+
+const DATA_PREFIX = `${DATA_IMPORT_PREFIX}/`;
+
+const isAssetSpecifier = (source: string): boolean => ASSET_PATH_RE.test(source);
+const isDataAsset = (source: string): boolean => source.startsWith(DATA_PREFIX) && ASSET_RE.test(source);
+
+export { DATA_PREFIX, isAssetSpecifier, isDataAsset };

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

@@ -1,4 +1,20 @@
 import type { Plugin } from "vite";
+import { posix } from "node:path";
+
+const EXECUTABLE_URL_BASE = "`file://${process.execPath}`";
+const LEADING_SLASHES = /^\/+/;
+
+const executableRelativeUrl = (target: string): string => {
+    const specifier = JSON.stringify(target.replace(LEADING_SLASHES, "./"));
+
+    return `decodeURIComponent(new URL(${specifier}, ${EXECUTABLE_URL_BASE}).pathname)`;
+};
+
+const bundleRelativeUrl = (filename: string): string => {
+    const specifier = JSON.stringify(`./${filename}`);
+
+    return `decodeURIComponent(new URL(${specifier}, import.meta.url).pathname)`;
+};
 
 const renderAssetUrl = (
     filename: string,
@@ -9,21 +25,11 @@ const renderAssetUrl = (
         return undefined;
     }
 
-    if (assetBase) {
-        const executableDir = "require(\"path\").dirname(process.execPath)";
-
-        return {
-            runtime:
-                `require("path").join(${executableDir},` +
-                `${JSON.stringify(assetBase)},${JSON.stringify(filename)})`,
-        };
+    if (assetBase === undefined) {
+        return { runtime: bundleRelativeUrl(filename) };
     }
 
-    const filenameLiteral = JSON.stringify(`./${filename}`);
-
-    return {
-        runtime: `new URL(${filenameLiteral}, import.meta.url).pathname`,
-    };
+    return { runtime: executableRelativeUrl(posix.join(assetBase, filename)) };
 };
 
 function gtkxBuiltUrl(assetBase?: string): Plugin {

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

@@ -0,0 +1,14 @@
+import type { Plugin } from "vite";
+import { ensureGenerated } from "../codegen/run-codegen.js";
+
+const TEST_MODE = "test";
+
+const gtkxEnsureStore = (): Plugin => ({
+    name: "gtkx:ensure-store",
+
+    async config() {
+        await ensureGenerated(process.cwd(), { shouldAnnounce: true, mode: TEST_MODE });
+    },
+});
+
+export { gtkxEnsureStore };

package/src/vite-plugins/esm-extension.ts

@@ -0,0 +1,4 @@
+const ESM_EXTENSION = ".mjs";
+const BUNDLE_FILENAME = `bundle${ESM_EXTENSION}`;
+
+export { BUNDLE_FILENAME, ESM_EXTENSION };

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

@@ -89,4 +89,4 @@ function gtkxRefreshRuntime(): Plugin {
 
 const gtkxFastRefresh = (): Plugin[] => [gtkxSwcRefresh(), gtkxRefreshRuntime()];
 
-export { gtkxSwcRefresh, gtkxRefreshRuntime, gtkxFastRefresh };
+export { gtkxFastRefresh };

package/src/vite-plugins/icons.ts

@@ -2,6 +2,7 @@ import type { Plugin, UserConfig } from "vite";
 import { info } from "@gtkx/utils";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import type { AssetEmitter } from "./asset-emitter.js";
 import { prependBanner } from "../internal/banner.js";
 import { resolveDataDir } from "../internal/data-dir.js";
 import { type ListedFile, listFilesRecursive } from "../internal/list-files.js";
@@ -10,10 +11,6 @@ type PluginState = {
     iconsDir: string | null;
 };
 
-type PluginContext = {
-    emitFile: (file: { type: "asset"; fileName: string; source: Buffer }) => void;
-};
-
 const ICONS_DIR = "icons";
 
 const XDG_ENV_BANNER = [
@@ -33,7 +30,7 @@ const resolveIconsDir = (config: UserConfig): string | null => {
     return dataDir === null ? null : join(root, dataDir, ICONS_DIR);
 };
 
-const emitIcons = (ctx: PluginContext, icons: ListedFile[]): void => {
+const emitIcons = (ctx: AssetEmitter, icons: ListedFile[]): void => {
     for (const { absPath, rel } of icons) {
         ctx.emitFile({ type: "asset", fileName: join(ICONS_DIR, rel), source: readFileSync(absPath) });
     }

package/src/vite-plugins/index.ts

@@ -1,11 +1,13 @@
 import type { Plugin } from "vite";
 import { createConfigLoader } from "@gtkx/config/internal";
 import createConfigPlugin from "@gtkx/config/vite-plugin";
+import { gtkxAssetImports } from "./asset-imports.js";
 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 { gtkxStoreLinks } from "./store-links.js";
 import { gtkxUndeclaredLibrary } from "./undeclared-library.js";
 
 const gtkxVitePlugins = (mode?: string): Plugin[] => {
@@ -13,9 +15,11 @@ const gtkxVitePlugins = (mode?: string): Plugin[] => {
 
     return [
         createConfigPlugin({ name: "gtkx:config", loadConfig }),
+        gtkxStoreLinks(),
         gtkxUndeclaredLibrary(loadConfig),
         gtkxSettings(),
         gtkxIcons(),
+        gtkxAssetImports(),
         gtkxResources(loadConfig),
         gtkxCss(),
         gtkxReactCompiler(loadConfig),

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

@@ -1,8 +1,9 @@
+import type { ConfigLoader } from "@gtkx/config";
 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 { type ConfigLoader, createConfigLoader } from "@gtkx/config/internal";
+import { createConfigLoader } from "@gtkx/config/internal";
 import babelPluginReactCompilerNs from "babel-plugin-react-compiler";
 
 type ReactCompilerState = {

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

@@ -5,6 +5,7 @@ const VIRTUAL_INIT = "\0gtkx-resources-init";
 const BUNDLE_FILENAME = "gtkx.gresource";
 const REL_SEPARATOR = "\0rel=";
 const REFRESH_EXPORT = "__refresh";
+const RESOURCE_PATH_EXPORT = "path";
 const { isVirtual, toVirtualId, fromVirtualId } = createVirtualNamespace(VIRTUAL_PREFIX);
 
 const escapeXml = (value: string): string =>
@@ -33,6 +34,7 @@ export {
     BUNDLE_FILENAME,
     REL_SEPARATOR,
     REFRESH_EXPORT,
+    RESOURCE_PATH_EXPORT,
     escapeXml,
     isVirtual,
     toVirtualId,

package/src/vite-plugins/resources.ts

@@ -1,15 +1,17 @@
+import type { ConfigLoader } from "@gtkx/config";
 import type { Plugin, ResolvedConfig, UserConfig, ViteDevServer } from "vite";
-import { type ConfigLoader, createConfigLoader } from "@gtkx/config/internal";
-import { error, formatChildProcessError, info, sortStrings } from "@gtkx/utils";
-import { execFileSync } from "node:child_process";
-import { copyFileSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { createConfigLoader } from "@gtkx/config/internal";
+import { error, info, sortStrings } from "@gtkx/utils";
+import { copyFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { DATA_IMPORT_PREFIX, resolveDataDir } from "../internal/data-dir.js";
+import type { AssetEmitter } from "./asset-emitter.js";
+import { resolveDataDir } from "../internal/data-dir.js";
 import { type ListedFile, listFilesRecursive } from "../internal/list-files.js";
-import { resolveCliTool } from "../internal/resolve-cli-tool.js";
-import { withStagingDir } from "../internal/staging-dir.js";
-import { ASSET_PATH_RE, ASSET_RE } from "./asset-extensions.js";
+import { loadModuleExclusively } from "../internal/module-loads.js";
+import { runCliTool } from "../internal/run-cli-tool.js";
+import { createRetainedStagingDir, type RetainedStagingDir, withStagingDir } from "../internal/staging-dir.js";
+import { ASSET_RE } from "./asset-extensions.js";
+import { DATA_PREFIX, isDataAsset } from "./asset-specifier.js";
 import { renderInitModule } from "./resource-init-module.js";
 import {
     BUNDLE_FILENAME,
@@ -18,10 +20,10 @@ import {
     isVirtual,
     REFRESH_EXPORT,
     REL_SEPARATOR,
+    RESOURCE_PATH_EXPORT,
     toVirtualId,
     VIRTUAL_INIT,
 } from "./resource-shared.js";
-import { stripQuery } from "./strip-query.js";
 
 type ResourceEntry = {
     sourcePath: string;
@@ -34,16 +36,16 @@ type PluginState = {
     isBuild: boolean;
     entries: Map<string, ResourceEntry>;
     sourcePaths: Set<string>;
-    devStagingDir: string | null;
+    stagingDir: RetainedStagingDir;
     devBundlePath: string;
     server: ViteDevServer | null;
     compiledSignature: string;
     dataDir: string | null;
 };
 
-const DATA_PREFIX = `${DATA_IMPORT_PREFIX}/`;
 const RESOURCE_COMPILER = "glib-compile-resources";
 const MANIFEST_PREFIX = "/";
+const DEV_STAGING_PREFIX = "resources-dev";
 
 const deriveResourcePrefix = (applicationId: string): string => `/${applicationId.replaceAll(".", "/")}`;
 
@@ -83,28 +85,22 @@ const stageBundle = (dir: string, entries: Map<string, ResourceEntry>): string =
 };
 
 const runCompiler = (sourceDir: string, manifest: string, outputPath: string): Buffer => {
-    try {
-        execFileSync(resolveCliTool(RESOURCE_COMPILER), [
-            `--sourcedir=${sourceDir}`,
-            `--target=${outputPath}`,
-            manifest,
-        ]);
-    } catch (error) {
-        const details = formatChildProcessError(error);
-        const suffix = details ? `:\n${details}` : "";
-        throw new Error(`${RESOURCE_COMPILER} failed${suffix}`, { cause: error });
-    }
+    runCliTool({
+        tool: RESOURCE_COMPILER,
+        args: [`--sourcedir=${sourceDir}`, `--target=${outputPath}`, manifest],
+    });
 
     return readFileSync(outputPath);
 };
 
 const ensureStagingDir = (state: PluginState): void => {
-    if (state.devStagingDir) {
-        return;
-    }
+    state.devBundlePath = join(state.stagingDir.retain(), BUNDLE_FILENAME);
+};
 
-    state.devStagingDir = mkdtempSync(join(tmpdir(), "gtkx-resources-dev-"));
-    state.devBundlePath = join(state.devStagingDir, BUNDLE_FILENAME);
+const releaseStagingDir = (state: PluginState): void => {
+    state.stagingDir.release();
+    state.devBundlePath = "";
+    state.compiledSignature = "";
 };
 
 const entriesSignature = (state: PluginState): string => sortStrings(state.entries.keys()).join("\0");
@@ -129,7 +125,7 @@ const reregisterDevBundle = async (state: PluginState): Promise<void> => {
         return;
     }
 
-    const mod = await server.ssrLoadModule(VIRTUAL_INIT);
+    const mod = await loadModuleExclusively(server, VIRTUAL_INIT);
     const refresh: unknown = mod[REFRESH_EXPORT];
 
     if (isRefreshHook(refresh)) {
@@ -180,25 +176,15 @@ const registerEntry = (state: PluginState, absPath: string, rel: string): Resour
 
 const isTrackedSource = (state: PluginState, file: string): boolean => state.sourcePaths.has(file);
 
-const dataAssetSource = (source: string): string | null => {
-    const clean = stripQuery(source);
-
-    if (!clean.startsWith(DATA_PREFIX) || !ASSET_PATH_RE.test(clean)) {
-        return null;
-    }
-
-    return clean;
-};
-
 const resolvedAssetId = (
     resolved: { id: string; external: boolean | string } | null,
-    clean: string,
+    source: string,
 ): string | undefined => {
     if (!resolved || resolved.external) {
         return undefined;
     }
 
-    return toVirtualId(resolved.id) + REL_SEPARATOR + clean.slice(DATA_PREFIX.length);
+    return toVirtualId(resolved.id) + REL_SEPARATOR + source.slice(DATA_PREFIX.length);
 };
 
 const loadInitModule = (state: PluginState): string => {
@@ -225,14 +211,11 @@ const loadAssetModule = (state: PluginState, virtualId: string): string => {
         `import { ensureRegistered } from ${JSON.stringify(VIRTUAL_INIT)};`,
         "ensureRegistered();",
         `export default ${JSON.stringify(uri)};`,
-        `export const path = ${JSON.stringify(entry.resourcePath)};`,
+        `export const ${RESOURCE_PATH_EXPORT} = ${JSON.stringify(entry.resourcePath)};`,
     ].join("\n");
 };
 
-const emitBuildBundle = (
-    ctx: { emitFile: (asset: { type: "asset"; fileName: string; source: Buffer }) => string },
-    state: PluginState,
-): void => {
+const emitBuildBundle = (ctx: AssetEmitter, state: PluginState): void => {
     if (!state.isBuild || state.entries.size === 0) {
         return;
     }
@@ -280,6 +263,12 @@ const attachResourceWatcher = (state: PluginState, server: ViteDevServer): void
         void refreshTrackedSource(state, file);
     };
 
+    const onClose = (): void => {
+        releaseStagingDir(state);
+    };
+
+    server.httpServer?.once("close", onClose);
+    server.watcher.once("close", onClose);
     server.watcher.on("change", onFileEvent);
     server.watcher.on("add", onFileEvent);
 };
@@ -313,7 +302,7 @@ function gtkxResources(loadConfig: ConfigLoader = createConfigLoader()): Plugin
         isBuild: false,
         entries: new Map(),
         sourcePaths: new Set(),
-        devStagingDir: null,
+        stagingDir: createRetainedStagingDir(DEV_STAGING_PREFIX),
         devBundlePath: "",
         server: null,
         compiledSignature: "",
@@ -342,15 +331,13 @@ function gtkxResources(loadConfig: ConfigLoader = createConfigLoader()): Plugin
                 return VIRTUAL_INIT;
             }
 
-            const clean = dataAssetSource(source);
-
-            if (clean === null) {
+            if (!isDataAsset(source)) {
                 return;
             }
 
-            const resolved = await this.resolve(clean, importer, { ...opts, skipSelf: true });
+            const resolved = await this.resolve(source, importer, { ...opts, skipSelf: true });
 
-            return resolvedAssetId(resolved, clean);
+            return resolvedAssetId(resolved, source);
         },
 
         load(id) {
@@ -360,6 +347,10 @@ function gtkxResources(loadConfig: ConfigLoader = createConfigLoader()): Plugin
         buildEnd() {
             emitBuildBundle(this, state);
         },
+
+        closeBundle() {
+            releaseStagingDir(state);
+        },
     };
 }