@gtkx/cli 1.3.0 → 1.5.0

package/src/i18n/types.ts

@@ -0,0 +1,154 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { SourceMessage } from "./source-messages.js";
+
+type I18nTypesResult = {
+    isWritten: boolean;
+    path: string;
+};
+
+const I18N_TYPES_FILENAME = "i18n.d.ts";
+const INTERPOLATION_PATTERN = /\{\{[^{}]+\}\}/u;
+
+const stringType = (values: string[]): string =>
+    [...new Set(values)].map((value) => JSON.stringify(value)).join(" | ");
+
+const contextField = (context: string | null): string =>
+    context === null ? "" : ` context: ${JSON.stringify(context)};`;
+
+const hasInterpolation = (values: string[]): boolean => values.some((value) => INTERPOLATION_PATTERN.test(value));
+
+const pointVariant = (message: SourceMessage): string => {
+    const isRequired = message.context !== null || hasInterpolation([message.msgid]);
+    const isInterpolated = hasInterpolation([message.msgid]);
+
+    return (
+        `{${contextField(message.context)} interpolated: ${String(isInterpolated)}; kind: "point"; ` +
+        `required: ${String(isRequired)}; value: ${JSON.stringify(message.msgid)} }`
+    );
+};
+
+const defaultVariant = (message: SourceMessage): string => {
+    const values = [message.singular];
+    const isInterpolated = hasInterpolation(values);
+    const isRequired = message.context !== null || isInterpolated;
+
+    return (
+        `{${contextField(message.context)} defaultValue: ${JSON.stringify(message.singular)}; ` +
+        `interpolated: ${String(isInterpolated)}; kind: "default"; required: ${String(isRequired)}; ` +
+        `value: ${stringType(values)} }`
+    );
+};
+
+const requirePlural = (message: SourceMessage): string => {
+    if (message.plural === null) {
+        throw new Error("Plural translation metadata requires a plural source string");
+    }
+
+    return message.plural;
+};
+
+const pluralVariant = (message: SourceMessage): string => {
+    const plural = requirePlural(message);
+    const values = [message.singular, plural];
+    const isInterpolated = hasInterpolation(values);
+
+    return (
+        `{${contextField(message.context)} defaultValue: ${JSON.stringify(plural)}; ` +
+        `interpolated: ${String(isInterpolated)}; kind: "plural"; required: true; ` +
+        `value: ${stringType(values)} }`
+    );
+};
+
+const pluralDefaultsVariant = (message: SourceMessage): string => {
+    const plural = requirePlural(message);
+    const values = [message.singular, plural];
+    const isInterpolated = hasInterpolation(values);
+
+    return (
+        `{${contextField(message.context)} defaultValueOne: ${JSON.stringify(message.singular)}; ` +
+        `defaultValueOther: ${JSON.stringify(plural)}; interpolated: ${String(isInterpolated)}; ` +
+        `kind: "pluralDefaults"; required: true; value: ${stringType(values)} }`
+    );
+};
+
+const variantsFor = (message: SourceMessage): string[] => {
+    if (message.kind === "plural") {
+        return [pluralVariant(message)];
+    }
+
+    if (message.kind === "pluralDefaults") {
+        return [pluralDefaultsVariant(message)];
+    }
+
+    return message.kind === "default" ? [defaultVariant(message)] : [pointVariant(message)];
+};
+
+const renderRegistry = (messages: SourceMessage[]): string[] => {
+    const entries: Map<string, Set<string>> = new Map();
+
+    for (const message of messages) {
+        const variants = entries.get(message.msgid) ?? new Set<string>();
+
+        for (const variant of variantsFor(message)) {
+            variants.add(variant);
+        }
+
+        entries.set(message.msgid, variants);
+    }
+
+    return [...entries]
+        .toSorted(([left], [right]) => left.localeCompare(right))
+        .map(([msgid, variants]) => `        ${JSON.stringify(msgid)}: ${[...variants].join(" | ")};`);
+};
+
+const generatedHeader = (): string[] => [
+    "/**",
+    " * Translation declarations generated by GTKX. Regenerated by",
+    " * `gtkx codegen`, `gtkx dev`, and `gtkx build`; do not edit.",
+    " */",
+];
+
+const renderI18nTypes = (messages: SourceMessage[], isEnabled = true): string => {
+    if (!isEnabled) {
+        return [...generatedHeader(), "export {};", ""].join("\n");
+    }
+
+    return [
+        ...generatedHeader(),
+        'import "@gtkx/i18n";',
+        "",
+        'declare module "@gtkx/i18n" {',
+        "    interface TranslationRegistry {",
+        ...renderRegistry(messages),
+        "    }",
+        "}",
+        "",
+    ].join("\n");
+};
+
+const i18nTypesPath = (root: string): string => join(root, "node_modules", ".gtkx", I18N_TYPES_FILENAME);
+
+const readFileOrNull = (path: string): string | null => {
+    try {
+        return readFileSync(path, "utf8");
+    } catch {
+        return null;
+    }
+};
+
+const emitI18nTypes = (root: string, messages: SourceMessage[], isEnabled = true): I18nTypesResult => {
+    const path = i18nTypesPath(root);
+    const content = renderI18nTypes(messages, isEnabled);
+
+    if (readFileOrNull(path) === content) {
+        return { isWritten: false, path };
+    }
+
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content);
+
+    return { isWritten: true, path };
+};
+
+export { I18N_TYPES_FILENAME, emitI18nTypes, i18nTypesPath };

package/src/internal/build-manifest.ts

@@ -0,0 +1,32 @@
+type RecordedPackage = {
+    name: string;
+    version: string | null;
+    dir: string;
+};
+
+type BuildManifest = {
+    generator: typeof BUILD_MANIFEST_GENERATOR;
+    formatVersion: typeof BUILD_MANIFEST_FORMAT_VERSION;
+    schemas: string[];
+    packages: RecordedPackage[];
+};
+
+type BuildManifestCollector = {
+    schemas: string[];
+};
+
+const BUILD_MANIFEST_FILENAME = "gtkx-schemas.json";
+const BUILD_MANIFEST_GENERATOR = "gtkx-build";
+const BUILD_MANIFEST_FORMAT_VERSION = 1;
+
+const createBuildManifestCollector = (): BuildManifestCollector => ({ schemas: [] });
+
+export {
+    BUILD_MANIFEST_FILENAME,
+    BUILD_MANIFEST_FORMAT_VERSION,
+    BUILD_MANIFEST_GENERATOR,
+    createBuildManifestCollector,
+    type BuildManifest,
+    type BuildManifestCollector,
+    type RecordedPackage,
+};

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,171 @@
+import type { ESTree, ParseResult, ParserOptions } from "vite";
+import { sortStringsBy } from "@gtkx/utils";
+import { type Dirent, readdirSync, readFileSync } from "node:fs";
+import { extname, join } from "node:path";
+import { parseSync, Visitor } 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 discoverSourceFiles = (dir: string): string[] => {
+    const files: string[] = [];
+    sourceFilesIn(dir, files);
+
+    return sortStringsBy(files, (path) => path);
+};
+
+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: ESTree.TemplateLiteral): string | null => {
+    const [quasi] = node.quasis;
+
+    return quasi === undefined || node.expressions.length > 0 ? null : quasi.value.cooked;
+};
+
+const literalImportSource = (node: ESTree.Expression): string | null => {
+    if (node.type === "TemplateLiteral") {
+        return templateImportSource(node);
+    }
+
+    return node.type === "Literal" && typeof node.value === "string" ? node.value : null;
+};
+
+const collectDynamicImportSources = (program: ESTree.Program, found: string[]): void => {
+    new Visitor({
+        ImportExpression: (node) => {
+            const source = literalImportSource(node.source);
+
+            if (source !== null) {
+                found.push(source);
+            }
+        },
+    }).visit(program);
+};
+
+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 = discoverSourceFiles(dir);
+    const imports = files.flatMap((path) => importsIn(path));
+
+    return sortStringsBy(imports, importKey);
+};
+
+export { discoverSourceFiles, discoverSourceImports, parseRuntimeImportsIn, type SourceImport, sourceLanguage };

package/src/mcp/client.ts

@@ -1,7 +1,13 @@
 import * as Gio from "@gtkx/gi/gio";
 import * as Gtk from "@gtkx/gi/gtk";
-import { DEFAULT_SOCKET_PATH, ErrorCode, ProtocolConnection, ProtocolError, type Request } from "@gtkx/mcp/internal";
-import { error, errorMessage, info, normalizeError, warn } from "@gtkx/utils";
+import {
+    DEFAULT_SOCKET_PATH,
+    isConnectionClosedError,
+    type JSONRPCRequest,
+    ProtocolConnection,
+    type Result,
+} from "@gtkx/mcp/internal";
+import { error, errorMessage, info, normalizeError } from "@gtkx/utils";
 import * as net from "node:net";
 import { dispatch } from "./handlers.js";
 import { WidgetRegistry } from "./widget-registry.js";
@@ -25,11 +31,6 @@ const RECONNECT_DELAY_MS = 2000;
 const REGISTER_TIMEOUT_MS = 30_000;
 const DISCONNECT_ERROR_CODES: Set<string> = new Set(["ENOENT", "ECONNREFUSED", "EPIPE", "ECONNRESET"]);
 
-const toResponseError = (error: unknown): { code: number; message: string; data?: unknown } =>
-    error instanceof ProtocolError
-        ? error.toErrorObject()
-        : { code: ErrorCode.INTERNAL_ERROR, message: errorMessage(error) };
-
 const connectSettler = (callbacks: ConnectCallbacks): ConnectSettler => {
     let isSettled = false;
 
@@ -82,7 +83,7 @@ class McpClient {
     private handleSocketError(socketError: Error): void {
         const code = (socketError as NodeJS.ErrnoException).code;
 
-        if (code !== undefined && DISCONNECT_ERROR_CODES.has(code)) {
+        if (isConnectionClosedError(socketError) || (code !== undefined && DISCONNECT_ERROR_CODES.has(code))) {
             this.scheduleReconnect();
         } else {
             error("Socket error:", socketError.message);
@@ -119,14 +120,7 @@ class McpClient {
             },
         });
 
-        connection.on("request", (request) => {
-            void this.handleRequest(request);
-        });
-
-        connection.on("invalid", ({ error: parseError }) => {
-            warn(`Received invalid JSON from MCP server: ${parseError.message}`);
-        });
-
+        connection.fallbackRequestHandler = (request) => this.handleRequest(request);
         this.socket = socket;
         this.connection = connection;
     }
@@ -158,35 +152,16 @@ class McpClient {
         );
     }
 
-    private async respondToRequest(request: Request): Promise<void> {
-        const { id, method, params } = request;
-        const connection = this.connection;
+    private handleRequest(request: JSONRPCRequest): Promise<Result> {
+        const defaultApp = Gio.Application.getDefault();
 
-        if (!connection) {
-            return;
+        if (!(defaultApp instanceof Gtk.Application)) {
+            throw new TypeError("Application not initialized");
         }
 
-        try {
-            const defaultApp = Gio.Application.getDefault();
-
-            if (!(defaultApp instanceof Gtk.Application)) {
-                throw new TypeError("Application not initialized");
-            }
+        this.registry.refresh();
 
-            this.registry.refresh();
-            const result = await dispatch(method, params, { app: defaultApp, registry: this.registry });
-            connection.write({ id, result });
-        } catch (dispatchError) {
-            connection.write({ id, error: toResponseError(dispatchError) });
-        }
-    }
-
-    private async handleRequest(request: Request): Promise<void> {
-        try {
-            await this.respondToRequest(request);
-        } catch (requestError) {
-            error("Error handling request:", requestError);
-        }
+        return dispatch(request.method, request.params, { app: defaultApp, registry: this.registry });
     }
 
     async connect(): Promise<void> {
@@ -219,10 +194,8 @@ class McpClient {
             this.reconnectTimer = null;
         }
 
-        this.connection?.rejectPending(new Error("Client disconnected"));
-
         if (this.socket) {
-            this.connection?.write({ id: crypto.randomUUID(), method: "app.unregister" });
+            void Promise.allSettled([this.connection?.send("app.unregister")]);
             this.socket.destroy();
             this.socket = null;
         }

package/src/mcp/handlers.ts

@@ -3,6 +3,7 @@ import {
     invalidRequestError,
     methodNotFoundError,
     type ParamsSchema,
+    type Result,
     type ServerInitiatedMethod,
     type ServerRequestParams,
     ServerRequestParamsSchemas,
@@ -18,10 +19,10 @@ type HandlerContext = {
     registry: WidgetRegistry;
 };
 
-type ValidatedHandler = (ctx: HandlerContext, params: unknown) => Promise<unknown>;
+type ValidatedHandler = (ctx: HandlerContext, params: unknown) => Promise<Result>;
 type WidgetTarget = { testing: TestingModule; widget: Gtk.Widget };
 type WidgetParams = { widgetId?: string | undefined };
-type TargetedHandler<Params> = (ctx: HandlerContext, target: WidgetTarget, params: Params) => Promise<unknown>;
+type TargetedHandler<Params> = (ctx: HandlerContext, target: WidgetTarget, params: Params) => Promise<Result>;
 type QueryParams = ServerRequestParams<"widget.query">;
 type QueryBy = QueryParams["by"];
 type QueryRunner = (testing: TestingModule, app: Gtk.Application, params: QueryParams) => Promise<Gtk.Widget[]>;
@@ -110,7 +111,7 @@ const SEARCHED_BY: Record<QueryBy, string> = {
 
 function validated<Params>(
     schema: ParamsSchema<Params>,
-    handler: (ctx: HandlerContext, params: Params) => Promise<unknown>,
+    handler: (ctx: HandlerContext, params: Params) => Promise<Result>,
 ): ValidatedHandler {
     return (ctx, params) => {
         const parsed = schema.safeParse(params ?? {});
@@ -229,7 +230,7 @@ const emptyQueryHint = (params: QueryParams): string =>
     "Call gtkx_get_widget_tree to see what is mounted; by:\"name\" is the widest match, and by:\"role\" accepts " +
     "options.name to match the accessible name of a known role.";
 
-async function handleQuery({ app, registry }: HandlerContext, params: QueryParams): Promise<unknown> {
+async function handleQuery({ app, registry }: HandlerContext, params: QueryParams): Promise<Result> {
     const testing = await loadTestingModule();
     const widgets = await QUERY_RUNNERS[params.by](testing, app, params);
     const resolveId = (widget: Gtk.Widget): string => registry.getOrCreateId(widget);
@@ -254,7 +255,7 @@ const defaultScreenshotTarget = (registry: WidgetRegistry): Gtk.Widget => {
 async function handleScreenshot(
     { registry }: HandlerContext,
     params: ServerRequestParams<"widget.screenshot">,
-): Promise<unknown> {
+): Promise<Result> {
     const testing = await loadTestingModule();
     const target = params.windowId ? requireWidget(registry, params.windowId) : defaultScreenshotTarget(registry);
     const result = await testing.screenshot(target, { path: params.path });
@@ -269,7 +270,7 @@ async function handleScreenshot(
 const isServerInitiatedMethod = (method: string): method is ServerInitiatedMethod =>
     Object.hasOwn(ServerRequestParamsSchemas, method);
 
-const dispatch = async (method: string, params: unknown, ctx: HandlerContext): Promise<unknown> => {
+const dispatch = async (method: string, params: unknown, ctx: HandlerContext): Promise<Result> => {
     if (!isServerInitiatedMethod(method)) {
         throw methodNotFoundError(method);
     }

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;
     }