@gtkx/cli 1.0.0 → 1.2.0

package/src/vite-plugins/resources.ts

@@ -2,15 +2,16 @@ import type { ConfigLoader } from "@gtkx/config";
 import type { Plugin, ResolvedConfig, UserConfig, ViteDevServer } from "vite";
 import { createConfigLoader } from "@gtkx/config/internal";
 import { error, info, sortStrings } from "@gtkx/utils";
-import { copyFileSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { copyFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import type { AssetEmitter } from "./asset-emitter.js";
-import { DATA_IMPORT_PREFIX, resolveDataDir } from "../internal/data-dir.js";
+import { resolveDataDir } from "../internal/data-dir.js";
 import { type ListedFile, listFilesRecursive } from "../internal/list-files.js";
+import { loadModuleExclusively } from "../internal/module-loads.js";
 import { runCliTool } from "../internal/run-cli-tool.js";
-import { withStagingDir } from "../internal/staging-dir.js";
-import { ASSET_PATH_RE, ASSET_RE } from "./asset-extensions.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,
@@ -19,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;
@@ -35,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(".", "/")}`;
 
@@ -93,12 +94,13 @@ const runCompiler = (sourceDir: string, manifest: string, outputPath: string): B
 };
 
 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");
@@ -123,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)) {
@@ -174,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 => {
@@ -219,7 +211,7 @@ 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");
 };
 
@@ -271,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);
 };
@@ -304,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: "",
@@ -333,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) {
@@ -351,6 +347,10 @@ function gtkxResources(loadConfig: ConfigLoader = createConfigLoader()): Plugin
         buildEnd() {
             emitBuildBundle(this, state);
         },
+
+        closeBundle() {
+            releaseStagingDir(state);
+        },
     };
 }
 

package/src/vite-plugins/self-contained.ts

@@ -0,0 +1,352 @@
+import type { Plugin } from "vite";
+import { isRecord } from "@gtkx/utils";
+import { isBuiltin } from "node:module";
+import { posix } from "node:path";
+import { parseSync } from "vite";
+
+type AstNode = Record<string, unknown>;
+
+type Bindings = {
+    declarations: Map<string, number>;
+    factories: Set<string>;
+    requires: Set<string>;
+    urls: Set<string>;
+};
+
+type Scan = {
+    bindings: Bindings;
+    calls: AstNode[];
+    sources: string[];
+};
+
+type Chunk = {
+    fileName: string;
+    code: string;
+};
+
+const REQUIRE_FACTORY = "createRequire";
+const REQUIRE_BINDING = "require";
+const RESOLVE_PROPERTY = "resolve";
+const MODULE_BUILTIN = "node:module";
+const OUTPUT_DIRECTORY = ".";
+const RELATIVE_SPECIFIER = /^\.\.?(?:\/|$)/;
+const DECLARATION_KEYS = ["id", "local", "param", "params"];
+
+const SOURCE_STATEMENTS = new Set([
+    "ExportAllDeclaration",
+    "ExportNamedDeclaration",
+    "ImportDeclaration",
+    "ImportExpression",
+]);
+
+const isAstNode = (value: unknown): value is AstNode => isRecord(value) && typeof value.type === "string";
+const nodeType = (node: AstNode): string => (typeof node.type === "string" ? node.type : "");
+
+const nodeName = (node: AstNode | null): string | null =>
+    node !== null && typeof node.name === "string" ? node.name : null;
+
+const childNode = (node: AstNode, key: string): AstNode | null => {
+    const value = node[key];
+
+    return isAstNode(value) ? value : null;
+};
+
+const childNodes = (node: AstNode, key: string): AstNode[] => {
+    const value = node[key];
+
+    if (!Array.isArray(value)) {
+        return [];
+    }
+
+    const entries: unknown[] = value;
+
+    return entries.filter(isAstNode);
+};
+
+const childValues = (value: unknown): unknown[] => {
+    if (Array.isArray(value)) {
+        const entries: unknown[] = value;
+
+        return entries;
+    }
+
+    if (!isAstNode(value)) {
+        return [];
+    }
+
+    return Object.values(value).filter((child) => typeof child === "object" && child !== null);
+};
+
+const visitNode = (value: unknown, visit: (node: AstNode) => void): void => {
+    if (isAstNode(value)) {
+        visit(value);
+    }
+};
+
+const walk = (root: unknown, visit: (node: AstNode) => void): void => {
+    const stack: unknown[] = [root];
+
+    while (stack.length > 0) {
+        const current = stack.pop();
+        visitNode(current, visit);
+
+        for (const value of childValues(current)) {
+            stack.push(value);
+        }
+    }
+};
+
+const countName = (declarations: Map<string, number>, node: AstNode): void => {
+    const name = nodeName(node);
+
+    if (name !== null) {
+        declarations.set(name, (declarations.get(name) ?? 0) + 1);
+    }
+};
+
+const countDeclarations = (node: AstNode, declarations: Map<string, number>): void => {
+    for (const key of DECLARATION_KEYS) {
+        walk(node[key], (declared) => {
+            countName(declarations, declared);
+        });
+    }
+};
+
+const isUnshadowed = (name: string, bindings: Bindings): boolean => (bindings.declarations.get(name) ?? 0) <= 1;
+
+const templateString = (node: AstNode): string | null => {
+    if (childNodes(node, "expressions").length > 0) {
+        return null;
+    }
+
+    const [quasi] = childNodes(node, "quasis");
+    const value = quasi === undefined ? null : quasi.value;
+
+    return isRecord(value) && typeof value.cooked === "string" ? value.cooked : null;
+};
+
+const literalString = (node: AstNode | null): string | null => {
+    if (node === null) {
+        return null;
+    }
+
+    if (nodeType(node) === "Literal") {
+        return typeof node.value === "string" ? node.value : null;
+    }
+
+    return nodeType(node) === "TemplateLiteral" ? templateString(node) : null;
+};
+
+const isMetaUrl = (node: AstNode, bindings: Bindings): boolean => {
+    if (nodeType(node) === "MemberExpression") {
+        const object = childNode(node, "object");
+
+        return object !== null && nodeType(object) === "MetaProperty";
+    }
+
+    const name = nodeName(node);
+
+    return name !== null && bindings.urls.has(name) && isUnshadowed(name, bindings);
+};
+
+const hasMetaUrl = (node: AstNode, bindings: Bindings): boolean =>
+    childNodes(node, "arguments").some((argument) => isMetaUrl(argument, bindings));
+
+const isRequireName = (name: string | null, bindings: Bindings): boolean =>
+    name !== null && (name === REQUIRE_BINDING || bindings.requires.has(name)) && isUnshadowed(name, bindings);
+
+const isFactoryName = (name: string | null, bindings: Bindings): boolean =>
+    name !== null && (name === REQUIRE_FACTORY || bindings.factories.has(name)) && isUnshadowed(name, bindings);
+
+const isRequireFactory = (node: AstNode, bindings: Bindings): boolean => {
+    if (nodeType(node) !== "CallExpression") {
+        return false;
+    }
+
+    return isFactoryName(nodeName(childNode(node, "callee")), bindings) || hasMetaUrl(node, bindings);
+};
+
+const isResolveTarget = (object: AstNode, bindings: Bindings): boolean =>
+    nodeType(object) === "MetaProperty" ||
+    isRequireName(nodeName(object), bindings) ||
+    isRequireFactory(object, bindings);
+
+const isResolveMember = (callee: AstNode, bindings: Bindings): boolean => {
+    if (nodeType(callee) !== "MemberExpression" || callee.computed === true) {
+        return false;
+    }
+
+    if (nodeName(childNode(callee, "property")) !== RESOLVE_PROPERTY) {
+        return false;
+    }
+
+    const object = childNode(callee, "object");
+
+    return object !== null && isResolveTarget(object, bindings);
+};
+
+const isResolvingCall = (call: AstNode, bindings: Bindings): boolean => {
+    if (hasMetaUrl(call, bindings)) {
+        return true;
+    }
+
+    const callee = childNode(call, "callee");
+
+    if (callee === null) {
+        return false;
+    }
+
+    return (
+        isRequireName(nodeName(callee), bindings) ||
+        isRequireFactory(callee, bindings) ||
+        isResolveMember(callee, bindings)
+    );
+};
+
+const collectFactories = (node: AstNode, bindings: Bindings): void => {
+    if (literalString(childNode(node, "source")) !== MODULE_BUILTIN) {
+        return;
+    }
+
+    for (const specifier of childNodes(node, "specifiers")) {
+        const local = nodeName(childNode(specifier, "local"));
+
+        if (local !== null && nodeName(childNode(specifier, "imported")) === REQUIRE_FACTORY) {
+            bindings.factories.add(local);
+        }
+    }
+};
+
+const collectBinding = (node: AstNode, bindings: Bindings): void => {
+    const name = nodeName(childNode(node, "id"));
+    const init = childNode(node, "init");
+
+    if (name === null || init === null) {
+        return;
+    }
+
+    if (isMetaUrl(init, bindings)) {
+        bindings.urls.add(name);
+    }
+
+    if (isRequireFactory(init, bindings)) {
+        bindings.requires.add(name);
+    }
+};
+
+const hasStringArgument = (call: AstNode): boolean =>
+    childNodes(call, "arguments").some((argument) => literalString(argument) !== null);
+
+const collectSource = (scan: Scan, node: AstNode, type: string): void => {
+    if (!SOURCE_STATEMENTS.has(type)) {
+        return;
+    }
+
+    const source = literalString(childNode(node, "source"));
+
+    if (source !== null) {
+        scan.sources.push(source);
+    }
+};
+
+const collectCall = (scan: Scan, node: AstNode, type: string): void => {
+    if (type === "CallExpression" && hasStringArgument(node)) {
+        scan.calls.push(node);
+    }
+};
+
+const scanNode = (scan: Scan, node: AstNode): void => {
+    const type = nodeType(node);
+    countDeclarations(node, scan.bindings.declarations);
+
+    if (type === "ImportDeclaration") {
+        collectFactories(node, scan.bindings);
+    } else if (type === "VariableDeclarator") {
+        collectBinding(node, scan.bindings);
+    }
+
+    collectSource(scan, node, type);
+    collectCall(scan, node, type);
+};
+
+const scanChunk = (chunk: Chunk): Scan => {
+    const scan: Scan = {
+        bindings: { declarations: new Map(), factories: new Set(), requires: new Set(), urls: new Set() },
+        calls: [],
+        sources: [],
+    };
+
+    walk(parseSync(chunk.fileName, chunk.code).program, (node) => {
+        scanNode(scan, node);
+    });
+
+    return scan;
+};
+
+const callSpecifiers = (scan: Scan): string[] =>
+    scan.calls
+        .filter((call) => isResolvingCall(call, scan.bindings))
+        .flatMap((call) => childNodes(call, "arguments"))
+        .map((argument) => literalString(argument))
+        .filter((specifier) => specifier !== null);
+
+const isReachable = (specifier: string, directory: string, emitted: Set<string>): boolean => {
+    if (isBuiltin(specifier)) {
+        return true;
+    }
+
+    if (!RELATIVE_SPECIFIER.test(specifier)) {
+        return false;
+    }
+
+    const target = posix.normalize(posix.join(directory, specifier));
+
+    return target === OUTPUT_DIRECTORY || emitted.has(target);
+};
+
+const unreachableSpecifiers = (chunk: Chunk, emitted: Set<string>): string[] => {
+    const scan = scanChunk(chunk);
+    const directory = posix.dirname(chunk.fileName);
+
+    return new Set([...scan.sources, ...callSpecifiers(scan)])
+        .values()
+        .filter((specifier) => !isReachable(specifier, directory, emitted))
+        .toArray()
+        .toSorted((left, right) => left.localeCompare(right));
+};
+
+const assertSelfContained = (chunk: Chunk, emitted: Set<string>): void => {
+    const specifiers = unreachableSpecifiers(chunk, emitted);
+
+    if (specifiers.length === 0) {
+        return;
+    }
+
+    throw new Error(
+        [
+            `${chunk.fileName} resolves ${specifiers.join(", ")} at runtime,`,
+            "so the built app only starts where that resolution succeeds from wherever it was installed.",
+            "The artifact may resolve node: builtins and the files the build emits beside it, nothing else:",
+            "bundle the module, emit the file, or read the data at build time.",
+        ].join(" "),
+    );
+};
+
+function gtkxSelfContained(): Plugin {
+    return {
+        name: "gtkx:self-contained",
+        apply: "build",
+
+        generateBundle(_options, bundle) {
+            const emitted = new Set(Object.keys(bundle));
+
+            for (const output of Object.values(bundle)) {
+                if (output.type === "chunk") {
+                    assertSelfContained({ fileName: output.fileName, code: output.code }, emitted);
+                }
+            }
+        },
+    };
+}
+
+export { gtkxSelfContained };

package/src/vite-plugins/settings.ts

@@ -1,12 +1,11 @@
 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 { readFileSync } from "node:fs";
 import { basename, 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 { removeTempDir, withStagingDir } from "../internal/staging-dir.js";
+import { createRetainedStagingDir, type RetainedStagingDir, withStagingDir } from "../internal/staging-dir.js";
 import { compileSchemas } from "../settings/compile.js";
 import { parseSchemaXml, SchemaParseError } from "../settings/parser.js";
 import { renderRuntimeModule } from "../settings/render.js";
@@ -14,13 +13,12 @@ import { emitSchemaEnv, prependSchemaDir, SCHEMA_SUFFIX, stageSchema } from "../
 import { createVirtualNamespace } from "./virtual-module.js";
 
 type PluginState = {
-    schemaDir: string | null;
+    schemaDir: RetainedStagingDir;
     rootDir: string | null;
     dataDir: string | null;
     isBuild: boolean;
     trackedSchemas: Map<string, string>;
     buildSchemas: Set<string>;
-    cleanupProcessExit: (() => void) | null;
 };
 
 type PluginContext = AssetEmitter & {
@@ -28,6 +26,7 @@ type PluginContext = AssetEmitter & {
 };
 
 const VIRTUAL_PREFIX = "\0gtkx-settings:";
+const SCHEMA_STAGING_PREFIX = "schemas";
 const { isVirtual, fromVirtualId, resolveToVirtual } = createVirtualNamespace(VIRTUAL_PREFIX);
 
 const SCHEMA_ENV_BANNER = [
@@ -40,50 +39,26 @@ const SCHEMA_ENV_BANNER = [
 ].join("\n");
 
 const ensureSchemaDir = (state: PluginState): string => {
-    if (!state.schemaDir) {
-        const runnerDir = process.env.GTKX_DEV_SCHEMA_DIR;
+    const existing = state.schemaDir.getPath();
 
-        if (runnerDir) {
-            state.schemaDir = runnerDir;
-
-            return runnerDir;
-        }
-
-        const dir = mkdtempSync(join(tmpdir(), "gtkx-schemas-"));
-        state.schemaDir = dir;
-
-        const cleanup = (): void => {
-            removeTempDir(dir);
-        };
-
-        state.cleanupProcessExit = cleanup;
-        process.once("exit", cleanup);
+    if (existing !== null) {
+        return existing;
     }
 
-    return state.schemaDir;
-};
+    const runnerDir = process.env.GTKX_DEV_SCHEMA_DIR;
 
-const releaseSchemaDir = (state: PluginState): void => {
-    if (!state.schemaDir) {
-        return;
-    }
-
-    if (state.cleanupProcessExit) {
-        removeTempDir(state.schemaDir);
-        process.removeListener("exit", state.cleanupProcessExit);
-        state.cleanupProcessExit = null;
-    }
-
-    state.schemaDir = null;
+    return runnerDir ? state.schemaDir.adopt(runnerDir) : state.schemaDir.retain();
 };
 
 const compileSchemaDir = (state: PluginState): void => {
-    if (!state.schemaDir) {
+    const dir = state.schemaDir.getPath();
+
+    if (dir === null) {
         return;
     }
 
-    compileSchemas(state.schemaDir);
-    process.env.GSETTINGS_SCHEMA_DIR = prependSchemaDir(state.schemaDir, process.env.GSETTINGS_SCHEMA_DIR);
+    compileSchemas(dir);
+    process.env.GSETTINGS_SCHEMA_DIR = prependSchemaDir(dir, process.env.GSETTINGS_SCHEMA_DIR);
 };
 
 const syncSchemaEnv = (state: PluginState): void => {
@@ -204,13 +179,12 @@ const handleSchemaHotUpdate = (state: PluginState, file: string, server: ViteDev
 };
 
 const watchSchemaFiles = (state: PluginState, server: ViteDevServer): void => {
-    server.httpServer?.once("close", () => {
-        releaseSchemaDir(state);
-    });
+    const onClose = (): void => {
+        state.schemaDir.release();
+    };
 
-    server.watcher.once("close", () => {
-        releaseSchemaDir(state);
-    });
+    server.httpServer?.once("close", onClose);
+    server.watcher.once("close", onClose);
 
     const refreshSchemaTypes = (file: string): void => {
         if (file.endsWith(SCHEMA_SUFFIX)) {
@@ -224,13 +198,12 @@ const watchSchemaFiles = (state: PluginState, server: ViteDevServer): void => {
 
 function gtkxSettings(): Plugin {
     const state: PluginState = {
-        schemaDir: null,
+        schemaDir: createRetainedStagingDir(SCHEMA_STAGING_PREFIX),
         rootDir: null,
         dataDir: null,
         isBuild: false,
         trackedSchemas: new Map(),
         buildSchemas: new Set(),
-        cleanupProcessExit: null,
     };
 
     return {
@@ -274,7 +247,7 @@ function gtkxSettings(): Plugin {
         },
 
         closeBundle() {
-            releaseSchemaDir(state);
+            state.schemaDir.release();
         },
 
         handleHotUpdate({ file, server }) {

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

@@ -0,0 +1,25 @@
+import type { Plugin, UserConfig } from "vite";
+import { ensureStoreLinks } from "@gtkx/codegen/internal";
+
+const GENERATED_MODULE_PREFIX = /^@gtkx\/(?:gi|jsx)\//;
+
+function gtkxStoreLinks(): Plugin {
+    const state = { root: "" };
+
+    return {
+        name: "gtkx:store-links",
+        enforce: "pre",
+
+        config(config: UserConfig) {
+            state.root = config.root ?? process.cwd();
+        },
+
+        resolveId(source) {
+            if (GENERATED_MODULE_PREFIX.test(source)) {
+                ensureStoreLinks(state.root);
+            }
+        },
+    };
+}
+
+export { gtkxStoreLinks };