@gtkx/cli 1.3.0 → 1.4.0

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

@@ -1,9 +1,81 @@
 import { DATA_IMPORT_PREFIX } from "../internal/data-dir.js";
 import { ASSET_PATH_RE, ASSET_RE } from "./asset-extensions.js";
+import { stripQuery } from "./strip-query.js";
+
+type ResourceSpecifier = {
+    assetSource: string;
+    resourcePath: string | null;
+};
+
+type IconSpecifier = {
+    assetSource: string;
+    iconName: string | null;
+};
 
 const DATA_PREFIX = `${DATA_IMPORT_PREFIX}/`;
+const RELATIVE_PREFIX_RE = /^\.\.?(?:\/|$)/;
+const RESOURCE_QUERY_RE = /^resource(?:=([^&#]+))?$/;
+const ICON_QUERY_RE = /^icon(?:=([^&#]+))?$/;
+const URL_QUERY_RE = /(?:^|&)url(?:&|$)/;
+
+const getQuery = (source: string): string | null => {
+    const queryIndex = source.indexOf("?");
+
+    return queryIndex === -1 ? null : source.slice(queryIndex + 1);
+};
 
 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 };
+const isBareRelativeAsset = (source: string): boolean =>
+    getQuery(source) === null && RELATIVE_PREFIX_RE.test(source) && ASSET_RE.test(source);
+
+const parseResourceSpecifier = (source: string): ResourceSpecifier | null => {
+    const query = getQuery(source);
+    const assetSource = stripQuery(source);
+
+    if (query === null || !ASSET_RE.test(assetSource)) {
+        return null;
+    }
+
+    const match = RESOURCE_QUERY_RE.exec(query);
+
+    if (match === null) {
+        return null;
+    }
+
+    return { assetSource, resourcePath: match[1] ?? null };
+};
+
+const parseIconSpecifier = (source: string): IconSpecifier | null => {
+    const query = getQuery(source);
+    const assetSource = stripQuery(source);
+
+    if (query === null || !ASSET_RE.test(assetSource)) {
+        return null;
+    }
+
+    const match = ICON_QUERY_RE.exec(query);
+
+    if (match === null) {
+        return null;
+    }
+
+    return { assetSource, iconName: match[1] ?? null };
+};
+
+const isUrlSpecifier = (source: string): boolean => {
+    const query = getQuery(source);
+
+    return query !== null && URL_QUERY_RE.test(query);
+};
+
+export {
+    DATA_PREFIX,
+    isAssetSpecifier,
+    isBareRelativeAsset,
+    isDataAsset,
+    isUrlSpecifier,
+    parseIconSpecifier,
+    parseResourceSpecifier,
+};

package/src/vite-plugins/{bundled-packages.ts → build-manifest.ts}

@@ -2,6 +2,14 @@ import type { Plugin } from "vite";
 import { isRecord, sortStringsBy } from "@gtkx/utils";
 import { readFileSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
+import {
+    BUILD_MANIFEST_FILENAME,
+    BUILD_MANIFEST_FORMAT_VERSION,
+    BUILD_MANIFEST_GENERATOR,
+    type BuildManifest,
+    type BuildManifestCollector,
+    type RecordedPackage,
+} from "../internal/build-manifest.js";
 import { stripQuery } from "./strip-query.js";
 
 type PackageIdentity = {
@@ -9,22 +17,17 @@ type PackageIdentity = {
     version: string | null;
 };
 
-type RecordedPackage = PackageIdentity & {
-    dir: string;
-};
-
-type PackagesState = {
+type ManifestState = {
     outDir: string;
 };
 
-const BUNDLED_PACKAGES_FILENAME = "gtkx-packages.json";
-const MANIFEST_FILENAME = "package.json";
+const PACKAGE_MANIFEST_FILENAME = "package.json";
 const DEFAULT_OUT_DIR = "dist";
 const JSON_INDENT = 4;
 
 const identityIn = (dir: string): PackageIdentity | null => {
     try {
-        const parsed: unknown = JSON.parse(readFileSync(join(dir, MANIFEST_FILENAME), "utf8"));
+        const parsed: unknown = JSON.parse(readFileSync(join(dir, PACKAGE_MANIFEST_FILENAME), "utf8"));
 
         if (!isRecord(parsed) || typeof parsed.name !== "string") {
             return null;
@@ -54,26 +57,27 @@ const packageForModule = (id: string): RecordedPackage | null => {
     return path.startsWith("/") ? packageIn(dirname(path)) : null;
 };
 
-const keyFor = (entry: RecordedPackage): string => `${entry.name}@${entry.version ?? ""}`;
+const packageKey = (entry: RecordedPackage): string => `${entry.name}@${entry.version ?? ""}`;
 
 const relativeTo = (outDir: string, entry: RecordedPackage): RecordedPackage => ({
     ...entry,
     dir: relative(outDir, entry.dir),
 });
 
-const renderPackages = (outDir: string, ids: string[]): string => {
+const packagesFor = (outDir: string, ids: string[]): RecordedPackage[] => {
     const found = ids.map((id) => packageForModule(id)).filter((entry) => entry !== null);
-    const unique: Map<string, RecordedPackage> = new Map(found.map((entry) => [keyFor(entry), entry]));
-    const packages = sortStringsBy(unique.values(), keyFor).map((entry) => relativeTo(outDir, entry));
+    const unique: Map<string, RecordedPackage> = new Map(found.map((entry) => [packageKey(entry), entry]));
 
-    return `${JSON.stringify({ packages }, null, JSON_INDENT)}\n`;
+    return sortStringsBy(unique.values(), packageKey).map((entry) => relativeTo(outDir, entry));
 };
 
-function gtkxBundledPackages(root: string): Plugin {
-    const state: PackagesState = { outDir: join(root, DEFAULT_OUT_DIR) };
+const renderManifest = (manifest: BuildManifest): string => `${JSON.stringify(manifest, null, JSON_INDENT)}\n`;
+
+function gtkxBuildManifest(root: string, collector: BuildManifestCollector): Plugin {
+    const state: ManifestState = { outDir: join(root, DEFAULT_OUT_DIR) };
 
     return {
-        name: "gtkx:bundled-packages",
+        name: "gtkx:build-manifest",
         apply: "build",
 
         configResolved(config) {
@@ -83,13 +87,20 @@ function gtkxBundledPackages(root: string): Plugin {
         generateBundle(_options, bundle) {
             const ids = Object.values(bundle).flatMap((output) => (output.type === "chunk" ? output.moduleIds : []));
 
+            const manifest: BuildManifest = {
+                generator: BUILD_MANIFEST_GENERATOR,
+                formatVersion: BUILD_MANIFEST_FORMAT_VERSION,
+                schemas: collector.schemas,
+                packages: packagesFor(state.outDir, ids),
+            };
+
             this.emitFile({
                 type: "asset",
-                fileName: BUNDLED_PACKAGES_FILENAME,
-                source: renderPackages(state.outDir, ids),
+                fileName: BUILD_MANIFEST_FILENAME,
+                source: renderManifest(manifest),
             });
         },
     };
 }
 
-export { BUNDLED_PACKAGES_FILENAME, gtkxBundledPackages };
+export { gtkxBuildManifest };

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

@@ -1,14 +1,12 @@
-import type { Plugin } from "vite";
-import { posix } from "node:path";
+import type { Plugin, UserConfig } from "vite";
+import { existsSync } from "node:fs";
+import { isAbsolute } from "node:path";
+import { stripQuery } from "./strip-query.js";
 
-const EXECUTABLE_URL_BASE = "`file://${process.execPath}`";
-const LEADING_SLASHES = /^\/+/;
+type PluginState = { isBuild: boolean };
+type WatchContext = { addWatchFile: (file: string) => void };
 
-const executableRelativeUrl = (target: string): string => {
-    const specifier = JSON.stringify(target.replace(LEADING_SLASHES, "./"));
-
-    return `decodeURIComponent(new URL(${specifier}, ${EXECUTABLE_URL_BASE}).pathname)`;
-};
+const URL_QUERY_RE = /\?url(?:&t=\d+)?$/;
 
 const bundleRelativeUrl = (filename: string): string => {
     const specifier = JSON.stringify(`./${filename}`);
@@ -19,36 +17,59 @@ const bundleRelativeUrl = (filename: string): string => {
 const renderAssetUrl = (
     filename: string,
     type: string,
-    assetBase: string | undefined,
 ): { runtime: string } | undefined => {
     if (type !== "asset") {
         return undefined;
     }
 
-    if (assetBase === undefined) {
-        return { runtime: bundleRelativeUrl(filename) };
+    return { runtime: bundleRelativeUrl(filename) };
+};
+
+const configureBuiltUrl = (userConfig: UserConfig, command: string): UserConfig | undefined => {
+    if (command !== "build" || userConfig.experimental?.renderBuiltUrl) {
+        return undefined;
     }
 
-    return { runtime: executableRelativeUrl(posix.join(assetBase, filename)) };
+    return {
+        experimental: {
+            renderBuiltUrl(filename, { type }) {
+                return renderAssetUrl(filename, type);
+            },
+        },
+    };
 };
 
-function gtkxBuiltUrl(assetBase?: string): Plugin {
+const loadDevFileUrl = (ctx: WatchContext, state: PluginState, id: string): string | undefined => {
+    if (state.isBuild || !URL_QUERY_RE.test(id)) {
+        return undefined;
+    }
+
+    const file = stripQuery(id);
+
+    if (!isAbsolute(file) || !existsSync(file)) {
+        return undefined;
+    }
+
+    ctx.addWatchFile(file);
+
+    return `export default ${JSON.stringify(file)};`;
+};
+
+function gtkxBuiltUrl(): Plugin {
+    const state: PluginState = { isBuild: false };
+
     return {
         name: "gtkx:built-url",
-        apply: "build",
-
-        config(userConfig) {
-            if (userConfig.experimental?.renderBuiltUrl) {
-                return;
-            }
-
-            return {
-                experimental: {
-                    renderBuiltUrl(filename, { type }) {
-                        return renderAssetUrl(filename, type, assetBase);
-                    },
-                },
-            };
+        enforce: "pre",
+
+        config: (userConfig, { command }) => configureBuiltUrl(userConfig, command),
+
+        configResolved(config) {
+            state.isBuild = config.command === "build";
+        },
+
+        load(id) {
+            return loadDevFileUrl(this, state, id);
         },
     };
 }

package/src/vite-plugins/icons.ts

@@ -1,14 +1,21 @@
+import type { ConfigLoader } from "@gtkx/config";
 import type { Plugin, UserConfig } from "vite";
+import { createConfigLoader } 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 { prependBanner } from "../internal/banner.js";
-import { resolveDataDir } from "../internal/data-dir.js";
+import {
+    relativeIconPath,
+    resolveApplicationIcon,
+    type ResolvedApplicationIcon,
+} from "../internal/icon-path.js";
 import { type ListedFile, listFilesRecursive } from "../internal/list-files.js";
 
 type PluginState = {
-    iconsDir: string | null;
+    applicationId: string;
+    source: ResolvedApplicationIcon;
 };
 
 const ICONS_DIR = "icons";
@@ -20,14 +27,25 @@ const XDG_ENV_BANNER = [
     "].join(\":\");",
 ].join("\n");
 
-const findIconFiles = (iconsDir: string | null): ListedFile[] =>
-    iconsDir === null ? [] : listFilesRecursive(iconsDir);
+const findIconFiles = (state: PluginState): ListedFile[] => {
+    if (state.source.kind === "theme") {
+        return listFilesRecursive(state.source.path);
+    }
+
+    if (state.source.kind === "none") {
+        return [];
+    }
 
-const resolveIconsDir = (config: UserConfig): string | null => {
-    const root = config.root ?? process.cwd();
-    const dataDir = resolveDataDir(root);
+    return [{
+        absPath: state.source.path,
+        rel: relativeIconPath(state.applicationId, state.source.path),
+    }];
+};
 
-    return dataDir === null ? null : join(root, dataDir, ICONS_DIR);
+const applyUserConfig = async (state: PluginState, config: UserConfig, loadConfig: ConfigLoader): Promise<void> => {
+    const { config: gtkxConfig, root } = await loadConfig.load(config.root ?? process.cwd());
+    state.applicationId = gtkxConfig.applicationId;
+    state.source = resolveApplicationIcon(root, gtkxConfig.applicationId, gtkxConfig.applicationIcon);
 };
 
 const emitIcons = (ctx: AssetEmitter, icons: ListedFile[]): void => {
@@ -40,9 +58,10 @@ const emitIcons = (ctx: AssetEmitter, icons: ListedFile[]): void => {
     }
 };
 
-function gtkxIcons(): Plugin {
+function gtkxIcons(loadConfig: ConfigLoader = createConfigLoader()): Plugin {
     const state: PluginState = {
-        iconsDir: null,
+        applicationId: "",
+        source: { kind: "none" },
     };
 
     return {
@@ -50,12 +69,12 @@ function gtkxIcons(): Plugin {
         enforce: "pre",
         apply: "build",
 
-        config(config: UserConfig) {
-            state.iconsDir = resolveIconsDir(config);
+        async config(config: UserConfig) {
+            await applyUserConfig(state, config, loadConfig);
         },
 
         outputOptions(options) {
-            if (findIconFiles(state.iconsDir).length === 0) {
+            if (findIconFiles(state).length === 0) {
                 return;
             }
 
@@ -63,7 +82,7 @@ function gtkxIcons(): Plugin {
         },
 
         buildEnd() {
-            emitIcons(this, findIconFiles(state.iconsDir));
+            emitIcons(this, findIconFiles(state));
         },
     };
 }

package/src/vite-plugins/index.ts

@@ -1,7 +1,9 @@
 import type { Plugin } from "vite";
 import { createConfigLoader } from "@gtkx/config/internal";
 import createConfigPlugin from "@gtkx/config/vite-plugin";
+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 { gtkxIcons } from "./icons.js";
 import { gtkxReactCompiler } from "./react-compiler.js";
@@ -10,17 +12,22 @@ import { gtkxSettings } from "./settings.js";
 import { gtkxStoreLinks } from "./store-links.js";
 import { gtkxUndeclaredLibrary } from "./undeclared-library.js";
 
-const gtkxVitePlugins = (mode?: string): Plugin[] => {
+const gtkxVitePlugins = (
+    mode?: string,
+    entryPath?: string,
+    buildManifest?: BuildManifestCollector,
+): Plugin[] => {
     const loadConfig = createConfigLoader(mode === undefined ? {} : { mode });
 
     return [
         createConfigPlugin({ name: "gtkx:config", loadConfig }),
         gtkxStoreLinks(),
         gtkxUndeclaredLibrary(loadConfig),
-        gtkxSettings(),
-        gtkxIcons(),
-        gtkxAssetImports(),
-        gtkxResources(loadConfig),
+        gtkxSettings(loadConfig, buildManifest),
+        gtkxIcons(loadConfig),
+        gtkxAssetImports(loadConfig),
+        gtkxBuiltUrl(),
+        gtkxResources(loadConfig, entryPath),
         gtkxCss(),
         gtkxReactCompiler(loadConfig),
     ];

package/src/vite-plugins/native.ts

@@ -6,6 +6,7 @@ import { dirname, join } from "node:path";
 import { stripQuery } from "./strip-query.js";
 
 const EMITTED_BINDING_SPECIFIER = "./gtkx.node";
+const BINDING_FILENAME = "gtkx.node";
 
 function resolveBinaryPath(projectRequire: ReturnType<typeof createRequire>, currentArch: string): string {
     const nativeRoot = dirname(projectRequire.resolve("@gtkx/native/package.json"));
@@ -30,7 +31,7 @@ function resolvePlatformBinary(projectRequire: ReturnType<typeof createRequire>)
     return readFileSync(resolveBinaryPath(projectRequire, currentArch));
 }
 
-function rewriteLoader(code: string): string {
+function rewriteLoader(code: string, bindingReferenceId: string): string {
     const idents: string[] = [];
 
     for (const match of code.matchAll(/export\s*\{\s*([A-Za-z0-9_$]+)\s*\}/g)) {
@@ -45,15 +46,37 @@ function rewriteLoader(code: string): string {
 
     return [
         "import { createRequire as __gtkxCreateRequire } from \"node:module\";",
-        `const __gtkxNative = __gtkxCreateRequire(import.meta.url)(${JSON.stringify(EMITTED_BINDING_SPECIFIER)});`,
+        "import { fileURLToPath as __gtkxFileURLToPath } from \"node:url\";",
+        `const __gtkxNativeLocation = import.meta.ROLLUP_FILE_URL_${bindingReferenceId};`,
+        "const __gtkxNativePath = __gtkxNativeLocation.startsWith(\"file:\") " +
+        "? __gtkxFileURLToPath(__gtkxNativeLocation) : __gtkxNativeLocation;",
+        "const __gtkxNative = __gtkxCreateRequire(import.meta.url)(__gtkxNativePath);",
         `const { ${bindings} } = __gtkxNative;`,
         `export { ${bindings} };`,
     ].join("\n");
 }
 
+const transformLoader = (
+    code: string,
+    id: string,
+    loaderPath: string,
+    bindingReferenceId: string | null,
+): string | null => {
+    if (stripQuery(id) !== loaderPath) {
+        return null;
+    }
+
+    if (bindingReferenceId === null) {
+        throw new Error("Cannot render the native loader before its binary has been emitted");
+    }
+
+    return rewriteLoader(code, bindingReferenceId);
+};
+
 function gtkxNative(root: string): Plugin {
     const projectRequire = createRequire(join(root, "package.json"));
     let cachedLoaderPath: string | undefined;
+    let bindingReferenceId: string | null = null;
 
     const loaderPath = (): string => {
         cachedLoaderPath ??= join(dirname(projectRequire.resolve("@gtkx/native/package.json")), "index.js");
@@ -67,7 +90,11 @@ function gtkxNative(root: string): Plugin {
         apply: "build",
 
         buildStart() {
-            this.emitFile({ type: "asset", fileName: "gtkx.node", source: resolvePlatformBinary(projectRequire) });
+            bindingReferenceId = this.emitFile({
+                type: "asset",
+                fileName: BINDING_FILENAME,
+                source: resolvePlatformBinary(projectRequire),
+            });
         },
 
         resolveId(id) {
@@ -75,7 +102,7 @@ function gtkxNative(root: string): Plugin {
         },
 
         transform(code, id) {
-            return stripQuery(id) === loaderPath() ? rewriteLoader(code) : null;
+            return transformLoader(code, id, loaderPath(), bindingReferenceId);
         },
     };
 }

package/src/vite-plugins/resource-init-module.ts

@@ -1,15 +1,33 @@
-import { BUNDLE_FILENAME, REFRESH_EXPORT } from "./resource-shared.js";
+import { REFRESH_EXPORT, REGISTER_REFRESH_EXPORT } from "./resource-shared.js";
 
-const buildInitModuleSource = (): string =>
+type InitModuleOptions = { isBuild: true; bundleReferenceId: string } |
+    { isBuild: false; devBundlePath: string };
+
+const refreshCallbackSource = (): string[] => [
+    "const refreshCallbacks = new Map();",
+    "",
+    `export function ${REGISTER_REFRESH_EXPORT}(key, callback) {`,
+    "    refreshCallbacks.set(key, callback);",
+    "    callback();",
+    "}",
+    "",
+    "function runRefreshCallbacks() {",
+    "    for (const callback of refreshCallbacks.values()) callback();",
+    "}",
+];
+
+const buildInitModuleSource = (bundleReferenceId: string): string =>
     [
-        "import { dirname, join } from \"node:path\";",
         "import { fileURLToPath } from \"node:url\";",
         "import { Resource, resourcesRegister } from \"@gtkx/gi/gio\";",
         "",
-        "const bundleDir = dirname(fileURLToPath(import.meta.url));",
-        `const resource = Resource.load(join(bundleDir, ${JSON.stringify(BUNDLE_FILENAME)}));`,
+        `const bundleLocation = import.meta.ROLLUP_FILE_URL_${bundleReferenceId};`,
+        "const bundlePath = bundleLocation.startsWith(\"file:\") ? fileURLToPath(bundleLocation) : bundleLocation;",
+        "const resource = Resource.load(bundlePath);",
         "resourcesRegister(resource);",
         "",
+        ...refreshCallbackSource(),
+        "",
         "export function ensureRegistered() {}",
         `export function ${REFRESH_EXPORT}() {}`,
     ].join("\n");
@@ -31,27 +49,38 @@ const devInitModuleSource = (bundlePath: string): string => {
         "    current = next;",
         "}",
         "",
+        "function unregister() {",
+        "    if (!current) return;",
+        "    resourcesUnregister(current);",
+        "    current = null;",
+        "    lastSig = \"\";",
+        "}",
+        "",
+        ...refreshCallbackSource(),
+        "",
         "export function ensureRegistered() {",
-        `    if (!existsSync(${bundlePathLiteral})) return;`,
+        `    if (!existsSync(${bundlePathLiteral})) {`,
+        "        unregister();",
+        "        return;",
+        "    }",
         `    const { size, mtimeMs } = statSync(${bundlePathLiteral});`,
         "    const sig = size + \":\" + mtimeMs;",
-        "    if (sig === lastSig) return;",
-        "    register();",
-        "    lastSig = sig;",
+        "    if (sig !== lastSig) {",
+        "        register();",
+        "        lastSig = sig;",
+        "    }",
         "}",
         "",
         "ensureRegistered();",
         "",
         `export function ${REFRESH_EXPORT}() {`,
-        `    if (!existsSync(${bundlePathLiteral})) return;`,
-        "    register();",
-        `    const { size, mtimeMs } = statSync(${bundlePathLiteral});`,
-        "    lastSig = size + \":\" + mtimeMs;",
+        "    ensureRegistered();",
+        "    runRefreshCallbacks();",
         "}",
     ].join("\n");
 };
 
-const renderInitModule = (options: { isBuild: boolean; devBundlePath: string }): string =>
-    options.isBuild ? buildInitModuleSource() : devInitModuleSource(options.devBundlePath);
+const renderInitModule = (options: InitModuleOptions): string =>
+    options.isBuild ? buildInitModuleSource(options.bundleReferenceId) : devInitModuleSource(options.devBundlePath);
 
 export { renderInitModule };

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

@@ -4,7 +4,9 @@ const VIRTUAL_PREFIX = "\0gtkx-resources:";
 const VIRTUAL_INIT = "\0gtkx-resources-init";
 const BUNDLE_FILENAME = "gtkx.gresource";
 const REL_SEPARATOR = "\0rel=";
+const ICON_NAME_SEPARATOR = "\0icon=";
 const REFRESH_EXPORT = "__refresh";
+const REGISTER_REFRESH_EXPORT = "__registerRefresh";
 const RESOURCE_PATH_EXPORT = "path";
 const { isVirtual, toVirtualId, fromVirtualId } = createVirtualNamespace(VIRTUAL_PREFIX);
 
@@ -33,7 +35,9 @@ export {
     VIRTUAL_INIT,
     BUNDLE_FILENAME,
     REL_SEPARATOR,
+    ICON_NAME_SEPARATOR,
     REFRESH_EXPORT,
+    REGISTER_REFRESH_EXPORT,
     RESOURCE_PATH_EXPORT,
     escapeXml,
     isVirtual,