@gtkx/cli 1.6.0 → 2.0.0-beta.2

package/src/internal/prepare-project.ts

@@ -2,22 +2,22 @@ import { ensureGeneratedIn } from "../codegen/run-codegen.js";
 import { type CodegenContext, resolveCodegenContext } from "../codegen/store-resolver.js";
 import { resolveCwd, resolveEntry } from "./entry-arg.js";
 
-type ProjectArgs = { entry?: string; cwd?: string };
-type PreparedProject = { cwd: string; entry: string };
+type ProjectArgs = { entry?: string; cwd?: string; config?: string };
+type PreparedProject = { cwd: string; entry: string; configFile: string };
 type ResolvedProject = PreparedProject & { context: CodegenContext };
 
 const resolveProject = async (args: ProjectArgs, mode: string): Promise<ResolvedProject> => {
     const cwd = resolveCwd(args);
-    const context = await resolveCodegenContext(cwd, mode);
+    const context = await resolveCodegenContext(cwd, mode, args.config);
 
-    return { cwd, entry: resolveEntry(cwd, args.entry), context };
+    return { cwd, entry: resolveEntry(cwd, args.entry), configFile: context.configFile, context };
 };
 
 const prepareProject = async (args: ProjectArgs, mode: string): Promise<PreparedProject> => {
     const { cwd, entry, context } = await resolveProject(args, mode);
     await ensureGeneratedIn(context, { shouldAnnounce: true, mode });
 
-    return { cwd, entry };
+    return { cwd, entry, configFile: context.configFile };
 };
 
 export { prepareProject, resolveProject };

package/src/internal/source-imports.ts

@@ -1,6 +1,6 @@
 import type { ESTree, ParseResult, ParserOptions } from "vite";
 import { sortStringsBy } from "@gtkx/utils";
-import { type Dirent, readdirSync, readFileSync } from "node:fs";
+import { globSync, readFileSync } from "node:fs";
 import { extname, join } from "node:path";
 import { parseSync, Visitor } from "vite";
 
@@ -13,8 +13,6 @@ type SourceLanguage = NonNullable<ParserOptions["lang"]>;
 type ParsedModule = ParseResult["module"];
 
 const SOURCE_LANGUAGES: Map<string, SourceLanguage> = new Map([
-    [".cjs", "jsx"],
-    [".cts", "ts"],
     [".js", "jsx"],
     [".jsx", "jsx"],
     [".mjs", "jsx"],
@@ -23,60 +21,26 @@ const SOURCE_LANGUAGES: Map<string, SourceLanguage> = new Map([
     [".tsx", "tsx"],
 ]);
 
-const EXCLUDED_DIRECTORIES: Set<string> = new Set([
-    "build",
-    "coverage",
-    "dist",
-    "node_modules",
-    "out-tsc",
-]);
-
 const sourceLanguage = (path: string): SourceLanguage | undefined => {
-    if (path.endsWith(".d.ts") || path.endsWith(".d.cts") || path.endsWith(".d.mts")) {
+    if (path.endsWith(".d.ts") || path.endsWith(".d.mts")) {
         return undefined;
     }
 
     return SOURCE_LANGUAGES.get(extname(path).toLowerCase());
 };
 
-const isWalkableDirectory = (name: string): boolean => !name.startsWith(".") && !EXCLUDED_DIRECTORIES.has(name);
-
-const collectSourceEntry = (dir: string, entry: Dirent, found: string[]): void => {
-    const path = join(dir, entry.name);
-
-    if (entry.isDirectory()) {
-        if (isWalkableDirectory(entry.name)) {
-            sourceFilesIn(path, found);
-        }
-
-        return;
-    }
-
-    if (entry.isFile() && sourceLanguage(path) !== undefined) {
-        found.push(path);
-    }
-};
-
-const sourceFilesIn = (dir: string, found: string[]): void => {
-    let entries: Dirent[];
-
-    try {
-        entries = readdirSync(dir, { withFileTypes: true });
-    } catch {
-        return;
-    }
-
-    for (const entry of entries) {
-        collectSourceEntry(dir, entry, found);
-    }
-};
-
-const discoverSourceFiles = (dir: string): string[] => {
-    const files: string[] = [];
-    sourceFilesIn(dir, files);
-
-    return sortStringsBy(files, (path) => path);
-};
+const discoverSourceFiles = (dir: string): string[] =>
+    sortStringsBy(
+        globSync("**/{*,.*}", {
+            cwd: dir,
+            exclude: ["**/{build,coverage,dist,node_modules,out-tsc}/**", "**/.gtkx-output-*/**"],
+            withFileTypes: true,
+        })
+            .filter((entry) => entry.isFile())
+            .map((entry) => join(entry.parentPath, entry.name))
+            .filter((path) => sourceLanguage(path) !== undefined),
+        (path) => path,
+    );
 
 const staticImportSources = (module: ParsedModule): string[] => [
     ...module.staticImports.map((statement) => statement.moduleRequest.value),

package/src/mcp/client.ts

@@ -1,10 +1,10 @@
 import * as Gio from "@gtkx/gi/gio";
 import * as Gtk from "@gtkx/gi/gtk";
 import {
-    DEFAULT_SOCKET_PATH,
     isConnectionClosedError,
     type JSONRPCRequest,
     ProtocolConnection,
+    resolveMcpSocketPath,
     type Result,
 } from "@gtkx/mcp/internal";
 import { error, errorMessage, info, normalizeError } from "@gtkx/utils";
@@ -65,7 +65,7 @@ class McpClient {
     private registry = new WidgetRegistry();
 
     constructor(options: McpClientOptions) {
-        this.socketPath = options.socketPath ?? DEFAULT_SOCKET_PATH;
+        this.socketPath = resolveMcpSocketPath(options.socketPath);
         this.applicationId = options.applicationId;
     }
 

package/src/settings/render.ts

@@ -9,7 +9,6 @@ type NamedSchema = {
 type EnvAssetDeclarations = {
     blocked: string[];
     icons: string[];
-    legacy: string[];
     resources: string[];
 };
 
@@ -209,15 +208,6 @@ const renderIconModule = (specifier: string): string => [
     "}",
 ].join("\n");
 
-const renderLegacyAssetModule = (specifier: string): string => [
-    `declare module ${toJsStringLiteral(specifier)} {`,
-    "    const resourceUri: string;",
-    "    const path: string;",
-    "    export { path };",
-    "    export default resourceUri;",
-    "}",
-].join("\n");
-
 const renderBlockedAssetModule = (specifier: string): string => [
     `declare module ${toJsStringLiteral(specifier)} {`,
     "    const assetImportRequiresResourceOrUrlQuery: {",
@@ -232,7 +222,7 @@ const renderEnvModule = (
     assetDeclarations?: EnvAssetDeclarations,
     options: EnvModuleOptions = {},
 ): string => {
-    const assets = assetDeclarations ?? { blocked: [], icons: [], legacy: [], resources: [] };
+    const assets = assetDeclarations ?? { blocked: [], icons: [], resources: [] };
     const usedNames: Set<string> = new Set();
 
     const schemas = files
@@ -241,7 +231,6 @@ const renderEnvModule = (
 
     const blocked = assets.blocked.map((specifier) => renderBlockedAssetModule(specifier));
     const icons = assets.icons.map((specifier) => renderIconModule(specifier));
-    const legacy = assets.legacy.map((specifier) => renderLegacyAssetModule(specifier));
     const resources = assets.resources.map((specifier) => renderResourceModule(specifier));
     const references = (options.references ?? []).map((path) => `/// <reference path=${JSON.stringify(path)} />`);
 
@@ -250,7 +239,6 @@ const renderEnvModule = (
         ...references,
         ...blocked,
         ...icons,
-        ...legacy,
         ...resources,
         ...schemas,
     ].join("\n\n")}\n`;

package/src/settings/schema.ts

@@ -1,25 +1,21 @@
-import { sortStrings, warn } from "@gtkx/utils";
+import { isPathInside, sortStrings, toPosixPath, warn } from "@gtkx/utils";
 import { createHash } from "node:crypto";
 import {
     copyFileSync,
-    type Dirent,
     existsSync,
     mkdirSync,
     mkdtempSync,
-    readdirSync,
     readFileSync,
     realpathSync,
     writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, join, relative, resolve } from "node:path";
 import { I18N_TYPES_FILENAME, i18nTypesPath } from "../i18n/types.js";
-import { DATA_IMPORT_PREFIX } from "../internal/data-dir.js";
 import { discoverSourceImports, type SourceImport } from "../internal/source-imports.js";
 import { removeTempDir } from "../internal/staging-dir.js";
 import {
     isBareRelativeAsset,
-    isDataAsset,
     parseIconSpecifier,
     parseResourceSpecifier,
 } from "../vite-plugins/asset-specifier.js";
@@ -57,27 +53,20 @@ const stageSchema = (dir: string, filePath: string): void => {
     copyFileSync(filePath, join(dir, stagedSchemaName(filePath)));
 };
 
-const toForwardSlashes = (value: string): string => value.replaceAll(/[/\\]/g, "/");
-
 const projectRelativeSchemaPath = (root: string, filePath: string): string | null => {
-    let rel: string;
+    let projectRoot: string;
+    let path: string;
 
     try {
-        rel = relative(realpathSync(root), realpathSync(filePath));
+        projectRoot = realpathSync(root);
+        path = realpathSync(filePath);
     } catch {
         return null;
     }
 
-    if (rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
-        return null;
-    }
-
-    return toForwardSlashes(rel);
+    return isPathInside(projectRoot, path) ? toPosixPath(relative(projectRoot, path)) : null;
 };
 
-const getModuleSpecifier = (dataDirAbs: string, filePath: string): string =>
-    `${DATA_IMPORT_PREFIX}/${toForwardSlashes(relative(dataDirAbs, filePath))}`;
-
 const getRelativeModuleSpecifier = (filePath: string): string => `*/${basename(filePath)}`;
 
 const sourceDirFor = (root: string): string => {
@@ -99,9 +88,6 @@ const findImportedSchemaFiles = (imports: SourceImport[]): string[] => {
     return sortStrings(new Set(files));
 };
 
-const legacyAssetSpecifier = (source: string): string | null =>
-    isDataAsset(source) ? source : null;
-
 const blockedAssetSpecifier = (source: string): string | null => {
     if (!isBareRelativeAsset(source)) {
         return null;
@@ -159,21 +145,15 @@ const iconModuleSpecifier = (source: string): string | null => {
 
 const findAssetModuleSpecifiers = (
     imports: SourceImport[],
-    isV2ResourceImports: boolean,
-): { blocked: string[]; icons: string[]; legacy: string[]; resources: string[] } => {
+): { blocked: string[]; icons: string[]; resources: string[] } => {
     const collect = (getSpecifier: (source: string) => string | null): string[] =>
         sortStrings(new Set(imports.map((entry) => getSpecifier(entry.source)).filter((value) => value !== null)));
 
-    if (isV2ResourceImports) {
-        return {
-            blocked: collect(blockedAssetSpecifier),
-            icons: collect(iconModuleSpecifier),
-            legacy: [],
-            resources: collect(resourceModuleSpecifier),
-        };
-    }
-
-    return { blocked: [], icons: [], legacy: collect(legacyAssetSpecifier), resources: [] };
+    return {
+        blocked: collect(blockedAssetSpecifier),
+        icons: collect(iconModuleSpecifier),
+        resources: collect(resourceModuleSpecifier),
+    };
 };
 
 const canonicalPath = (path: string): string => {
@@ -203,41 +183,10 @@ const assertUniqueSchemaBasenames = (schemaFiles: string[]): void => {
     }
 };
 
-const readVisibleEntries = (dir: string): Dirent[] => {
-    try {
-        return readdirSync(dir, { withFileTypes: true }).filter((entry) => !entry.name.startsWith("."));
-    } catch {
-        return [];
-    }
-};
-
-const isSchemaFile = (entry: Dirent): boolean => entry.isFile() && entry.name.endsWith(SCHEMA_SUFFIX);
-
-const collectSchemaFiles = (dir: string, found: string[]): void => {
-    for (const entry of readVisibleEntries(dir)) {
-        const full = join(dir, entry.name);
-
-        if (entry.isDirectory()) {
-            collectSchemaFiles(full, found);
-        } else if (isSchemaFile(entry)) {
-            found.push(full);
-        }
-    }
-};
-
-const findSchemaFiles = (dataDir: string): string[] => {
-    const found: string[] = [];
-    collectSchemaFiles(dataDir, found);
-
-    return sortStrings(found);
-};
-
-const stageAndCompileProjectSchemas = (root: string, dataDir: string | null): string | null => {
+const stageAndCompileProjectSchemas = (root: string): string | null => {
     const imports = discoverSourceImports(sourceDirFor(root));
-    const imported = findImportedSchemaFiles(imports);
-    assertUniqueSchemaBasenames(imported);
-    const legacy = dataDir === null ? [] : findSchemaFiles(join(root, dataDir));
-    const schemaFiles = sortStrings(new Set([...legacy, ...imported]));
+    const schemaFiles = findImportedSchemaFiles(imports);
+    assertUniqueSchemaBasenames(schemaFiles);
 
     if (schemaFiles.length === 0) {
         return null;
@@ -307,25 +256,14 @@ const didWriteChanges = (path: string, content: string): boolean => {
     return true;
 };
 
-const emitSchemaEnv = (
-    rootDir: string,
-    dataDir: string | null,
-    isV2ResourceImports = false,
-): SchemaEnvResult => {
-    const dataDirAbs = dataDir === null ? null : join(rootDir, dataDir);
-    const legacyFiles = dataDirAbs === null ? [] : findSchemaFiles(dataDirAbs);
+const emitSchemaEnv = (rootDir: string): SchemaEnvResult => {
     const imports = discoverSourceImports(sourceDirFor(rootDir));
-
-    const legacy = dataDirAbs === null
-        ? []
-        : parseProjectSchemas(legacyFiles, (filePath) => getModuleSpecifier(dataDirAbs, filePath));
-
     const importedFiles = findImportedSchemaFiles(imports);
     assertUniqueSchemaBasenames(importedFiles);
     const imported = parseProjectSchemas(importedFiles, getRelativeModuleSpecifier);
-    const assets = findAssetModuleSpecifiers(imports, isV2ResourceImports);
+    const assets = findAssetModuleSpecifiers(imports);
     const references = existsSync(i18nTypesPath(rootDir)) ? [`./${I18N_TYPES_FILENAME}`] : [];
-    const content = renderEnvModule([...legacy, ...imported], assets, { references });
+    const content = renderEnvModule(imported, assets, { references });
     const path = schemaEnvPath(rootDir);
     const isWritten = didWriteChanges(path, content);
 

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

@@ -1,13 +1,9 @@
-import type { ConfigLoader } from "@gtkx/config";
-import type { ParseResult, Plugin, UserConfig } from "vite";
-import { createConfigLoader, resolveFuture } from "@gtkx/config/internal";
+import type { ParseResult, Plugin } from "vite";
 import { parseSync } from "vite";
 import { sourceLanguage } from "../internal/source-imports.js";
 import { ASSET_MENTION_RE } from "./asset-extensions.js";
 import {
-    DATA_PREFIX,
     isAssetSpecifier,
-    isDataAsset,
     isUrlSpecifier,
     parseIconSpecifier,
     parseResourceSpecifier,
@@ -21,18 +17,11 @@ type ExportStatement = ParsedModule["staticExports"][number];
 type ExportEntry = ExportStatement["entries"][number];
 type BindingEntry = { importName: { name: string | null }; isType: boolean };
 type NamedBinding = { name: string; source: string };
-type PluginState = { isV2: boolean };
 
 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 URL asset exports only its default filesystem path; import the default instead of ${RESOURCE_BINDING}.`;
@@ -43,9 +32,7 @@ const RESOURCE_ADVICE =
 const ICON_ADVICE = "An icon asset exports only its default icon-theme name, and nothing else.";
 
 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}`;
+    "Add ?resource for a GResource, ?icon for a themed icon, or ?url for an emitted file.";
 
 const boundName = (entry: BindingEntry): string | null => {
     const { name } = entry.importName;
@@ -78,50 +65,46 @@ const bindings = (parsed: ParsedModule): NamedBinding[] => [
     ...parsed.staticExports.flatMap((statement) => exportBindings(statement)),
 ];
 
-const isBacked = ({ name, source }: NamedBinding, isV2: boolean): boolean => {
+const isBacked = ({ name, source }: NamedBinding): boolean => {
     if (name !== RESOURCE_PATH_EXPORT) {
         return false;
     }
 
-    return isV2 ? parseResourceSpecifier(source) !== null : isDataAsset(source);
+    return parseResourceSpecifier(source) !== null;
 };
 
 const isCheckedSpecifier = (source: string): boolean => isAssetSpecifier(source) || isUrlSpecifier(source);
 
-const unbackedBinding = (parsed: ParsedModule, isV2: boolean): NamedBinding | undefined =>
-    bindings(parsed).find((binding) => isCheckedSpecifier(binding.source) && !isBacked(binding, isV2));
-
-const isBundledResource = (source: string, isV2: boolean): boolean =>
-    isV2
-        ? parseResourceSpecifier(source) !== null || parseIconSpecifier(source) !== null
-        : isDataAsset(source);
+const unbackedBinding = (parsed: ParsedModule): NamedBinding | undefined =>
+    bindings(parsed).find((binding) => isCheckedSpecifier(binding.source) && !isBacked(binding));
 
-const v2BundleAdvice = (source: string): string =>
-    parseIconSpecifier(source) === null ? RESOURCE_ADVICE : ICON_ADVICE;
+const adviceFor = (source: string): string => {
+    if (parseResourceSpecifier(source) !== null) {
+        return RESOURCE_ADVICE;
+    }
 
-const bundleAdvice = (source: string, isV2: boolean): string => {
-    if (isBundledResource(source, isV2)) {
-        return isV2 ? v2BundleAdvice(source) : BUNDLE_ADVICE;
+    if (parseIconSpecifier(source) !== null) {
+        return ICON_ADVICE;
     }
 
     if (isUrlSpecifier(source)) {
         return QUERY_ADVICE;
     }
 
-    return source.startsWith(DATA_PREFIX) ? QUERY_ADVICE : RELATIVE_ADVICE;
+    return RELATIVE_ADVICE;
 };
 
-const unbackedBindingError = (path: string, binding: NamedBinding, isV2: boolean): Error =>
+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, isV2),
+        adviceFor(binding.source),
     );
 
 const isCheckedSource = (path: string): boolean => !path.startsWith(VIRTUAL_PREFIX) && !NODE_MODULES.test(path);
 const hasCheckedAssetMention = (code: string): boolean => ASSET_MENTION_RE.test(code) || code.includes("?url");
 
-const checkAssetImports = (code: string, id: string, isV2: boolean): void => {
+const checkAssetImports = (code: string, id: string): void => {
     const path = stripQuery(id);
     const lang = sourceLanguage(path);
 
@@ -135,27 +118,20 @@ const checkAssetImports = (code: string, id: string, isV2: boolean): void => {
         return;
     }
 
-    const binding = unbackedBinding(parsed.module, isV2);
+    const binding = unbackedBinding(parsed.module);
 
     if (binding !== undefined) {
-        throw unbackedBindingError(path, binding, isV2);
+        throw unbackedBindingError(path, binding);
     }
 };
 
-function gtkxAssetImports(loadConfig: ConfigLoader = createConfigLoader()): Plugin {
-    const state: PluginState = { isV2: false };
-
+function gtkxAssetImports(): Plugin {
     return {
         name: "gtkx:asset-imports",
         enforce: "pre",
 
-        async config(config: UserConfig) {
-            const loaded = await loadConfig.load(config.root ?? process.cwd());
-            state.isV2 = resolveFuture(loaded.config.future).isResourceImported;
-        },
-
         transform(code, id) {
-            checkAssetImports(code, id, state.isV2);
+            checkAssetImports(code, id);
         },
     };
 }

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

@@ -1,4 +1,3 @@
-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";
 
@@ -12,7 +11,6 @@ type IconSpecifier = {
     iconName: string | null;
 };
 
-const DATA_PREFIX = `${DATA_IMPORT_PREFIX}/`;
 const RELATIVE_PREFIX_RE = /^\.\.?(?:\/|$)/;
 const RESOURCE_QUERY_RE = /^resource(?:=([^&#]+))?$/;
 const ICON_QUERY_RE = /^icon(?:=([^&#]+))?$/;
@@ -25,7 +23,6 @@ const getQuery = (source: string): string | null => {
 };
 
 const isAssetSpecifier = (source: string): boolean => ASSET_PATH_RE.test(source);
-const isDataAsset = (source: string): boolean => source.startsWith(DATA_PREFIX) && ASSET_RE.test(source);
 
 const isBareRelativeAsset = (source: string): boolean =>
     getQuery(source) === null && RELATIVE_PREFIX_RE.test(source) && ASSET_RE.test(source);
@@ -71,10 +68,8 @@ const isUrlSpecifier = (source: string): boolean => {
 };
 
 export {
-    DATA_PREFIX,
     isAssetSpecifier,
     isBareRelativeAsset,
-    isDataAsset,
     isUrlSpecifier,
     parseIconSpecifier,
     parseResourceSpecifier,

package/src/vite-plugins/build-manifest.ts

@@ -21,6 +21,11 @@ type ManifestState = {
     outDir: string;
 };
 
+type BuildConfigIdentity = {
+    configFile: string;
+    configDigest: string;
+};
+
 const PACKAGE_MANIFEST_FILENAME = "package.json";
 const DEFAULT_OUT_DIR = "dist";
 const JSON_INDENT = 4;
@@ -73,7 +78,7 @@ const packagesFor = (outDir: string, ids: string[]): RecordedPackage[] => {
 
 const renderManifest = (manifest: BuildManifest): string => `${JSON.stringify(manifest, null, JSON_INDENT)}\n`;
 
-function gtkxBuildManifest(root: string, collector: BuildManifestCollector): Plugin {
+function gtkxBuildManifest(root: string, collector: BuildManifestCollector, identity: BuildConfigIdentity): Plugin {
     const state: ManifestState = { outDir: join(root, DEFAULT_OUT_DIR) };
 
     return {
@@ -90,6 +95,7 @@ function gtkxBuildManifest(root: string, collector: BuildManifestCollector): Plu
             const manifest: BuildManifest = {
                 generator: BUILD_MANIFEST_GENERATOR,
                 formatVersion: BUILD_MANIFEST_FORMAT_VERSION,
+                ...identity,
                 schemas: collector.schemas,
                 packages: packagesFor(state.outDir, ids),
             };