@gtkx/cli 1.0.0-rc.4 → 1.1.0

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,11 +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";
@@ -13,21 +13,20 @@ 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 = {
+type PluginContext = AssetEmitter & {
     error: (message: string) => never;
-    emitFile: (file: { type: "asset"; fileName: string; source: Buffer }) => void;
 };
 
 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 };

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

@@ -1,7 +1,10 @@
-import type { ConfigLoader } from "@gtkx/config/internal";
+import type { StoreOptions } from "@gtkx/codegen";
+import type { ConfigLoader } from "@gtkx/config";
 import type { Plugin, UserConfig } from "vite";
-import { discoverGirNamespaces, resolveGirPath } from "@gtkx/codegen";
+import { discoverGirNamespaces, resolveGirPath, resolveStore } from "@gtkx/codegen";
 import { createConfigLoader } from "@gtkx/config/internal";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 
 type PluginState = {
     root: string;
@@ -9,7 +12,14 @@ type PluginState = {
     girPath: string[] | null;
 };
 
-const GENERATED_MODULE_PATTERN = /^@gtkx\/(?:gi|jsx)\/([a-z0-9]+)$/;
+type GeneratedModule = {
+    source: string;
+    kind: string;
+    namespace: string;
+    importer: string;
+};
+
+const GENERATED_MODULE_PATTERN = /^@gtkx\/(gi|jsx)\/([a-z0-9]+)$/;
 
 const girSearchPaths = async (state: PluginState): Promise<string[]> => {
     if (state.girPath === null) {
@@ -25,24 +35,76 @@ const getNamespace = (identifier: string): string => identifier.slice(0, identif
 const findGirIdentifier = (girPath: string[], namespace: string): string | undefined =>
     discoverGirNamespaces(girPath).find((identifier) => getNamespace(identifier) === namespace);
 
-const undeclaredLibraryError = (source: string, namespace: string, girPath: string[]): Error => {
-    const identifier = findGirIdentifier(girPath, namespace);
+const parseGeneratedModule = (source: string, importer: string | undefined): GeneratedModule | null => {
+    const matched = GENERATED_MODULE_PATTERN.exec(source);
+    const kind = matched?.[1];
+    const namespace = matched?.[2];
+
+    if (kind === undefined || namespace === undefined) {
+        return null;
+    }
+
+    return { source, kind, namespace, importer: importer ?? "the project's sources" };
+};
+
+const getStoreOptions = (root: string, kind: string): StoreOptions | null => {
+    try {
+        const store = resolveStore(root);
+
+        return kind === "gi" ? store.gi : store.jsx;
+    } catch {
+        return null;
+    }
+};
+
+const hasNamespaceModule = (storeDir: string, namespace: string): boolean => {
+    const manifest = join(storeDir, "package.json");
+
+    if (!existsSync(manifest)) {
+        return false;
+    }
+
+    const { exports } = JSON.parse(readFileSync(manifest, "utf8")) as { exports?: Record<string, unknown> };
+
+    return exports?.[`./${namespace}`] !== undefined;
+};
+
+const unreachableStoreError = (generated: GeneratedModule, options: StoreOptions): Error =>
+    new Error(
+        `Cannot resolve "${generated.source}": the generated store in ${options.storeDir} does provide ` +
+        `"${generated.namespace}", but its link at ${options.linkDir} is not on the module resolution path of ` +
+        `${generated.importer}. Codegen writes the store into the node_modules the installed @gtkx packages ` +
+        "resolve from; install them where the importing file reaches them, then run gtkx codegen again.",
+    );
+
+const undeclaredLibraryError = (generated: GeneratedModule, girPath: string[]): Error => {
+    const identifier = findGirIdentifier(girPath, generated.namespace);
 
     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.",
+            `Cannot resolve "${generated.source}": the binding store has no "${generated.namespace}" module, and no ` +
+            `GIR data for it was found in [${girPath.join(", ")}]. If "${generated.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. ` +
+        `Cannot resolve "${generated.source}": the "${identifier}" bindings have not been generated. ` +
         `Add "${identifier}" to \`libraries\` in gtkx.config.ts, then run gtkx dev or gtkx build again.`,
     );
 };
 
+const unresolvedModuleError = async (state: PluginState, generated: GeneratedModule): Promise<Error> => {
+    const options = getStoreOptions(state.root, generated.kind);
+
+    if (options !== null && hasNamespaceModule(options.storeDir, generated.namespace)) {
+        return unreachableStoreError(generated, options);
+    }
+
+    return undeclaredLibraryError(generated, await girSearchPaths(state));
+};
+
 function gtkxUndeclaredLibrary(loadConfig: ConfigLoader = createConfigLoader()): Plugin {
     const state: PluginState = {
         root: "",
@@ -59,9 +121,9 @@ function gtkxUndeclaredLibrary(loadConfig: ConfigLoader = createConfigLoader()):
         },
 
         async resolveId(source, importer, options) {
-            const namespace = GENERATED_MODULE_PATTERN.exec(source)?.[1];
+            const generated = parseGeneratedModule(source, importer);
 
-            if (namespace === undefined) {
+            if (generated === null) {
                 return;
             }
 
@@ -71,7 +133,7 @@ function gtkxUndeclaredLibrary(loadConfig: ConfigLoader = createConfigLoader()):
                 return;
             }
 
-            throw undeclaredLibraryError(source, namespace, await girSearchPaths(state));
+            throw await unresolvedModuleError(state, generated);
         },
     };
 }