@gtkx/cli 1.2.2 → 1.4.0

package/src/internal/icon-path.ts

@@ -0,0 +1,127 @@
+import { type Stats, statSync } from "node:fs";
+import { basename, extname, isAbsolute, join, relative, resolve } from "node:path";
+
+type ResolvedApplicationIcon = { kind: "file"; path: string } |
+    { kind: "none" } |
+    { kind: "theme"; path: string };
+
+const ICON_EXTENSIONS: Set<string> = new Set([".svg", ".png", ".xpm"]);
+const SCALABLE_DIR = "hicolor/scalable/apps";
+const SIZE_PATTERN = /^(?<width>[1-9]\d{0,3})x(?<height>[1-9]\d{0,3})$/;
+const SIZE_SEPARATORS = /[-_.]/;
+
+const isInside = (parent: string, candidate: string): boolean => {
+    const rel = relative(parent, candidate);
+
+    return rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel);
+};
+
+const getStats = (path: string): Stats | undefined => {
+    try {
+        return statSync(path, { throwIfNoEntry: false });
+    } catch {
+        return undefined;
+    }
+};
+
+const iconExtension = (file: string): string => {
+    const extension = extname(file).toLowerCase();
+
+    if (!ICON_EXTENSIONS.has(extension)) {
+        throw new Error(`Cannot use ${file} as an application icon: expected an SVG, PNG, or XPM file`);
+    }
+
+    return extension;
+};
+
+const defaultIconFiles = (root: string, applicationId: string): string[] =>
+    [...ICON_EXTENSIONS]
+        .map((extension) => join(root, `${applicationId}${extension}`))
+        .filter((path) => getStats(path)?.isFile() === true);
+
+const resolveDefaultApplicationIcon = (root: string, applicationId: string): ResolvedApplicationIcon => {
+    const files = defaultIconFiles(root, applicationId);
+
+    if (files.length === 0) {
+        return { kind: "none" };
+    }
+
+    if (files.length > 1) {
+        throw new Error(
+            `Found multiple default application icons for ${applicationId}; set \`applicationIcon\` to choose one`,
+        );
+    }
+
+    const path = files[0];
+
+    if (path === undefined) {
+        return { kind: "none" };
+    }
+
+    return { kind: "file", path };
+};
+
+const resolveApplicationIcon = (
+    root: string,
+    applicationId: string,
+    configured: string | undefined,
+): ResolvedApplicationIcon => {
+    if (configured === undefined) {
+        return resolveDefaultApplicationIcon(root, applicationId);
+    }
+
+    if (isAbsolute(configured)) {
+        throw new Error(`Cannot use "${configured}" as the application icon: expected a project-relative path`);
+    }
+
+    const path = resolve(root, configured);
+
+    if (!isInside(root, path)) {
+        throw new Error(`Cannot use "${configured}" as the application icon: it is outside ${root}`);
+    }
+
+    const stats = getStats(path);
+
+    if (stats?.isDirectory() === true) {
+        return { kind: "theme", path };
+    }
+
+    if (stats?.isFile() !== true) {
+        throw new Error(`Cannot read the application icon "${configured}": no such file or directory under ${root}`);
+    }
+
+    iconExtension(path);
+
+    return { kind: "file", path };
+};
+
+const squareSize = (token: string): number | null => {
+    const groups = SIZE_PATTERN.exec(token)?.groups;
+
+    if (groups === undefined || groups.width !== groups.height) {
+        return null;
+    }
+
+    return Number(groups.width);
+};
+
+const iconThemeDir = (file: string, extension: string): string => {
+    if (extension === ".svg") {
+        return SCALABLE_DIR;
+    }
+
+    const size = basename(file)
+        .split(SIZE_SEPARATORS)
+        .map((token) => squareSize(token))
+        .find((value) => value !== null);
+
+    return size === undefined ? SCALABLE_DIR : `hicolor/${String(size)}x${String(size)}/apps`;
+};
+
+const relativeIconPath = (applicationId: string, file: string): string => {
+    const extension = iconExtension(file);
+
+    return `${iconThemeDir(file, extension)}/${applicationId}${extension}`;
+};
+
+export { relativeIconPath, resolveApplicationIcon, type ResolvedApplicationIcon };

package/src/internal/source-imports.ts

@@ -0,0 +1,200 @@
+import type { ParseResult, ParserOptions } from "vite";
+import { isRecord, sortStringsBy } from "@gtkx/utils";
+import { type Dirent, readdirSync, readFileSync } from "node:fs";
+import { extname, join } from "node:path";
+import { parseSync } from "vite";
+
+type SourceImport = {
+    importer: string;
+    source: string;
+};
+
+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"],
+    [".mts", "ts"],
+    [".ts", "ts"],
+    [".tsx", "tsx"],
+]);
+
+const EXCLUDED_DIRECTORIES: Set<string> = new Set([
+    ".git",
+    ".gtkx",
+    "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")) {
+        return undefined;
+    }
+
+    return SOURCE_LANGUAGES.get(extname(path).toLowerCase());
+};
+
+const collectSourceEntry = (dir: string, entry: Dirent, found: string[]): void => {
+    const path = join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+        if (!EXCLUDED_DIRECTORIES.has(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 staticImportSources = (module: ParsedModule): string[] => [
+    ...module.staticImports.map((statement) => statement.moduleRequest.value),
+    ...module.staticExports.flatMap((statement) =>
+        statement.entries
+            .map((entry) => entry.moduleRequest?.value)
+            .filter((source): source is string => source !== undefined),
+    ),
+];
+
+const staticRuntimeImportSources = (module: ParsedModule): string[] => [
+    ...module.staticImports
+        .filter((statement) => statement.entries.length === 0 || statement.entries.some((entry) => !entry.isType))
+        .map((statement) => statement.moduleRequest.value),
+    ...module.staticExports.flatMap((statement) =>
+        statement.entries
+            .filter((entry) => !entry.isType)
+            .map((entry) => entry.moduleRequest?.value)
+            .filter((source): source is string => source !== undefined),
+    ),
+];
+
+const templateImportSource = (node: Record<string, unknown>): string | null => {
+    if (!Array.isArray(node.expressions) || node.expressions.length > 0 || !Array.isArray(node.quasis)) {
+        return null;
+    }
+
+    const quasis: unknown[] = node.quasis;
+    const first: unknown = quasis[0];
+
+    if (!isRecord(first) || !isRecord(first.value)) {
+        return null;
+    }
+
+    return typeof first.value.cooked === "string" ? first.value.cooked : null;
+};
+
+const literalImportSource = (node: unknown): string | null => {
+    if (!isRecord(node)) {
+        return null;
+    }
+
+    if (node.type === "Literal") {
+        return typeof node.value === "string" ? node.value : null;
+    }
+
+    return node.type === "TemplateLiteral" ? templateImportSource(node) : null;
+};
+
+const collectDynamicImportArray = (nodes: unknown[], found: string[]): void => {
+    for (const child of nodes) {
+        collectDynamicImportSources(child, found);
+    }
+};
+
+const collectDynamicImportRecord = (node: Record<string, unknown>, found: string[]): void => {
+    if (node.type === "ImportExpression") {
+        const source = literalImportSource(node.source);
+
+        if (source !== null) {
+            found.push(source);
+        }
+
+        return;
+    }
+
+    collectDynamicImportArray(Object.values(node), found);
+};
+
+const collectDynamicImportSources = (node: unknown, found: string[]): void => {
+    if (Array.isArray(node)) {
+        collectDynamicImportArray(node, found);
+
+        return;
+    }
+
+    if (!isRecord(node)) {
+        return;
+    }
+
+    collectDynamicImportRecord(node, found);
+};
+
+const parseImportsInWith = (
+    path: string,
+    staticSources: (module: ParsedModule) => string[],
+): SourceImport[] | null => {
+    const lang = sourceLanguage(path);
+
+    if (lang === undefined) {
+        return [];
+    }
+
+    let parsed: ParseResult;
+
+    try {
+        parsed = parseSync(path, readFileSync(path, "utf8"), { lang });
+    } catch {
+        return null;
+    }
+
+    if (parsed.errors.length > 0) {
+        return null;
+    }
+
+    const sources = staticSources(parsed.module);
+    collectDynamicImportSources(parsed.program, sources);
+
+    return [...new Set(sources)].map((source) => ({ importer: path, source }));
+};
+
+const parseImportsIn = (path: string): SourceImport[] | null => parseImportsInWith(path, staticImportSources);
+
+const parseRuntimeImportsIn = (path: string): SourceImport[] | null =>
+    parseImportsInWith(path, staticRuntimeImportSources);
+
+const importsIn = (path: string): SourceImport[] => parseImportsIn(path) ?? [];
+const importKey = (entry: SourceImport): string => `${entry.importer}\0${entry.source}`;
+
+const discoverSourceImports = (dir: string): SourceImport[] => {
+    const files: string[] = [];
+    sourceFilesIn(dir, files);
+    const imports = files.flatMap((path) => importsIn(path));
+
+    return sortStringsBy(imports, importKey);
+};
+
+export { discoverSourceImports, parseRuntimeImportsIn, type SourceImport };

package/src/mcp/widget-properties.ts

@@ -6,13 +6,14 @@ import {
     getHandle,
     getInstanceType,
     type Handle,
+    isReadableProperty,
     TYPE_ENUM,
     TYPE_FLAGS,
     typeIsA,
     typeName,
 } from "@gtkx/runtime";
 import { fromValue, getValueType } from "@gtkx/runtime/internal";
-import { camelCase, errorMessage, kebabCase } from "@gtkx/utils";
+import { errorMessage, kebabCase } from "@gtkx/utils";
 import type { WidgetRegistry } from "./widget-registry.js";
 
 type PropertyRepresentation = Omit<SerializedProperty, "type">;
@@ -39,18 +40,6 @@ function prototypesFor(widget: Gtk.Widget): object[] {
     return prototypes;
 }
 
-function getAccessor(widget: Gtk.Widget, member: string): PropertyDescriptor | undefined {
-    for (const prototype of prototypesFor(widget)) {
-        const descriptor = Object.getOwnPropertyDescriptor(prototype, member);
-
-        if (descriptor !== undefined) {
-            return descriptor;
-        }
-    }
-
-    return undefined;
-}
-
 function getReadableNames(prototype: object): string[] {
     const descriptors = Object.entries(Object.getOwnPropertyDescriptors(prototype));
 
@@ -64,7 +53,7 @@ function readablePropertyNames(widget: Gtk.Widget): string[] {
 }
 
 const requireReadableProperty = (widget: Gtk.Widget, property: string): void => {
-    if (getAccessor(widget, camelCase(property))?.get !== undefined) {
+    if (isReadableProperty(getInstanceType(widget), property)) {
         return;
     }
 

package/src/settings/render.ts

@@ -1,19 +1,56 @@
-import { upperFirst } from "@gtkx/utils";
+import { camelCase, sanitizeIdentifier, upperFirst } from "@gtkx/utils";
 import type { ParsedKey, ParsedSchema, ParsedSchemaFile } from "./parser.js";
 
+type NamedSchema = {
+    schema: ParsedSchema;
+    exportName: string;
+};
+
+type EnvAssetDeclarations = {
+    blocked: string[];
+    icons: string[];
+    legacy: string[];
+    resources: string[];
+};
+
 const GTKX_ENV_MODULE_HEADER = `/**
- * GSettings schema modules generated by GTKX from the project's
- * \`.gschema.xml\` files. Regenerated by \`gtkx codegen\`, \`gtkx dev\`, and
- * \`gtkx build\`; do not edit.
+ * Project import declarations generated by GTKX. Regenerated by
+ * \`gtkx codegen\`, \`gtkx dev\`, and \`gtkx build\`; do not edit.
  */`;
 
 const ENUM_KIND = "enum";
 const FLAGS_KIND = "flags";
+const ID_SEPARATOR = /[._]/;
+const NAME_SEPARATOR = "_";
 
 const toJsStringLiteral = (value: string): string =>
     JSON.stringify(value).replaceAll("\u{2028}", String.raw`\u2028`).replaceAll("\u{2029}", String.raw`\u2029`);
 
-const getExportName = (schemaId: string): string => schemaId.replaceAll(".", "_");
+const getExportName = (schemaId: string): string =>
+    sanitizeIdentifier(schemaId.split(ID_SEPARATOR).map((part) => camelCase(part)).join(NAME_SEPARATOR));
+
+const collisionError = (file: ParsedSchemaFile, taken: string, schemaId: string, name: string): Error =>
+    new Error(
+        `${file.fileName} declares ${taken} and ${schemaId}, which both export \`${name}\`. ` +
+        "Rename one of the schema ids so that every schema in the file gets an export of its own.",
+    );
+
+const getNamedSchemas = (file: ParsedSchemaFile): NamedSchema[] => {
+    const owners: Map<string, string> = new Map();
+
+    return file.schemas.map((schema) => {
+        const exportName = getExportName(schema.id);
+        const taken = owners.get(exportName);
+
+        if (taken !== undefined) {
+            throw collisionError(file, taken, schema.id, exportName);
+        }
+
+        owners.set(exportName, schema.id);
+
+        return { schema, exportName };
+    });
+};
 
 const runtimeKindForKey = (key: ParsedKey): string => {
     if (key.enumId !== null) {
@@ -37,26 +74,27 @@ const getRuntimeKeys = (schema: ParsedSchema): string => {
 
 const renderRuntimeModule = (file: ParsedSchemaFile): string => {
     const lines: string[] = [];
+    const named = getNamedSchemas(file);
 
-    for (const [index, schema] of file.schemas.entries()) {
+    for (const [index, { schema, exportName }] of named.entries()) {
         const keysName = `keys_${String(index)}`;
         const id = toJsStringLiteral(schema.id);
         lines.push(`const ${keysName} = ${getRuntimeKeys(schema)};`);
 
         if (schema.path === null) {
             lines.push(
-                `export const ${getExportName(schema.id)} = { id: ${id}, keys: ${keysName}, ` +
+                `export const ${exportName} = { id: ${id}, keys: ${keysName}, ` +
                 `at: (path) => ({ id: ${id}, path, keys: ${keysName} }) };`,
             );
         } else {
-            lines.push(`export const ${getExportName(schema.id)} = { id: ${id}, path: null, keys: ${keysName} };`);
+            lines.push(`export const ${exportName} = { id: ${id}, path: null, keys: ${keysName} };`);
         }
     }
 
-    const first = file.schemas[0];
+    const first = named[0];
 
     if (first !== undefined) {
-        lines.push(`export default ${getExportName(first.id)};`);
+        lines.push(`export default ${first.exportName};`);
     }
 
     return lines.join("\n");
@@ -106,9 +144,7 @@ const boundRefTypeLines = (interfaceName: string, indent: string): string[] => [
     `${indent}keys: ${interfaceName};`,
 ];
 
-const renderSchemaConst = (schema: ParsedSchema, interfaceName: string): string[] => {
-    const exportName = getExportName(schema.id);
-
+const renderSchemaConst = ({ schema, exportName }: NamedSchema, interfaceName: string): string[] => {
     if (schema.path !== null) {
         return [
             `    const ${exportName}: {`,
@@ -130,17 +166,17 @@ const renderSchemaConst = (schema: ParsedSchema, interfaceName: string): string[
 };
 
 const renderFileModule = (file: ParsedSchemaFile, usedNames: Set<string>): string[] => {
-    const lines = [`declare module "${file.fileName}" {`];
+    const lines = [`declare module ${toJsStringLiteral(file.fileName)} {`];
     const exportNames: string[] = [];
 
-    for (const [index, schema] of file.schemas.entries()) {
+    for (const [index, named] of getNamedSchemas(file).entries()) {
         if (index > 0) {
             lines.push("");
         }
 
-        const interfaceName = allocateInterfaceName(schema.id, usedNames);
-        lines.push(...renderKeysType(interfaceName, schema), "", ...renderSchemaConst(schema, interfaceName));
-        exportNames.push(getExportName(schema.id));
+        const interfaceName = allocateInterfaceName(named.schema.id, usedNames);
+        lines.push(...renderKeysType(interfaceName, named.schema), "", ...renderSchemaConst(named, interfaceName));
+        exportNames.push(named.exportName);
     }
 
     const [firstExport] = exportNames;
@@ -154,14 +190,56 @@ const renderFileModule = (file: ParsedSchemaFile, usedNames: Set<string>): strin
     return lines;
 };
 
-const renderEnvModule = (files: ParsedSchemaFile[]): string => {
+const renderResourceModule = (specifier: string): string => [
+    `declare module ${toJsStringLiteral(specifier)} {`,
+    "    const path: string;",
+    "    export { path };",
+    "    export default path;",
+    "}",
+].join("\n");
+
+const renderIconModule = (specifier: string): string => [
+    `declare module ${toJsStringLiteral(specifier)} {`,
+    "    const iconName: string;",
+    "    export default iconName;",
+    "}",
+].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: {",
+    "        readonly __gtkxAssetImportRequiresResourceOrUrlQuery: unique symbol;",
+    "    };",
+    "    export default assetImportRequiresResourceOrUrlQuery;",
+    "}",
+].join("\n");
+
+const renderEnvModule = (
+    files: ParsedSchemaFile[],
+    assetDeclarations?: EnvAssetDeclarations,
+): string => {
+    const assets = assetDeclarations ?? { blocked: [], icons: [], legacy: [], resources: [] };
     const usedNames: Set<string> = new Set();
 
-    const blocks = files
+    const schemas = files
         .filter((file) => file.schemas.length > 0)
         .map((file) => renderFileModule(file, usedNames).join("\n"));
 
-    return `${[GTKX_ENV_MODULE_HEADER, ...blocks].join("\n\n")}\n`;
+    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));
+
+    return `${[GTKX_ENV_MODULE_HEADER, ...blocked, ...icons, ...legacy, ...resources, ...schemas].join("\n\n")}\n`;
 };
 
 export { renderRuntimeModule, renderEnvModule };