@gtkx/codegen 1.0.0-rc.1 → 1.0.0-rc.2

package/src/gir/namespace.ts

@@ -1,20 +1,20 @@
+import type { ParseContext, TypeId } from "./type-id.js";
 import { callbackFromNode, type GirCallback } from "./callback.js";
 import { classFromNode, type GirClass } from "./class.js";
 import { enumFromNode, type GirEnum } from "./enum.js";
 import { functionFromNode, type GirFunction } from "./function.js";
-import { attr, childOf, childrenOf, docOf, nameAttr, type RawNode } from "./parse.js";
+import { attr, getChild, getChildren, getDoc, nameAttr, type RawNode } from "./parse.js";
 import { type GirRecord, isVtableRecord, recordFromNode } from "./record.js";
-import type { ParseContext, TypeId } from "./type-id.js";
 import { typeRefFromNode } from "./type-ref.js";
 
-export type GirConstant = {
+type GirConstant = {
     name: string;
     doc: string | undefined;
     value: string;
     type: TypeId | undefined;
 };
 
-export type GirAlias = {
+type GirAlias = {
     name: string;
     doc: string | undefined;
     cType: string | undefined;
@@ -22,7 +22,7 @@ export type GirAlias = {
     targetCType: string | undefined;
 };
 
-export type GirNamespace = {
+type GirNamespace = {
     id: number;
     name: string;
     sharedLibrary: string | undefined;
@@ -37,14 +37,12 @@ export type GirNamespace = {
     aliases: GirAlias[];
 };
 
-export const namespaceDirectory = (namespace: Pick<GirNamespace, "name">): string => namespace.name.toLowerCase();
-
 type NamespaceInclude = {
     name: string;
     version: string;
 };
 
-export type NamespaceHeader = {
+type NamespaceHeader = {
     name: string;
     sharedLibrary: string | undefined;
     cSymbolPrefixes: string[];
@@ -52,15 +50,20 @@ export type NamespaceHeader = {
     namespaceNode: RawNode;
 };
 
-export const parseNamespaceHeader = (repositoryNode: RawNode): NamespaceHeader => {
-    const includes = childrenOf(repositoryNode, "include").map<NamespaceInclude>((include) => ({
+const namespaceDirectory = (namespace: Pick<GirNamespace, "name">): string => namespace.name.toLowerCase();
+
+const parseNamespaceHeader = (repositoryNode: RawNode): NamespaceHeader => {
+    const includes = getChildren(repositoryNode, "include").map<NamespaceInclude>((include) => ({
         name: nameAttr(include),
         version: attr(include, "version") ?? "",
     }));
-    const namespaceNode = childrenOf(repositoryNode, "namespace")[0];
+
+    const namespaceNode = getChildren(repositoryNode, "namespace")[0];
+
     if (namespaceNode === undefined) {
         throw new Error("GIR repository has no <namespace> child");
     }
+
     return {
         name: nameAttr(namespaceNode),
         sharedLibrary: attr(namespaceNode, "shared-library"),
@@ -70,7 +73,7 @@ export const parseNamespaceHeader = (repositoryNode: RawNode): NamespaceHeader =
     };
 };
 
-export const createNamespaceShell = (header: NamespaceHeader, id: number): GirNamespace => ({
+const createNamespaceShell = (header: NamespaceHeader, id: number): GirNamespace => ({
     id,
     name: header.name,
     sharedLibrary: header.sharedLibrary,
@@ -85,25 +88,27 @@ export const createNamespaceShell = (header: NamespaceHeader, id: number): GirNa
     aliases: [],
 });
 
-export const populateNamespaceBody = (shell: GirNamespace, namespaceNode: RawNode, context: ParseContext): void => {
-    shell.classes = childrenOf(namespaceNode, "class").map((klass) => classFromNode(klass, false, context));
-    shell.interfaces = childrenOf(namespaceNode, "interface").map((iface) => classFromNode(iface, true, context));
+const populateNamespaceBody = (shell: GirNamespace, namespaceNode: RawNode, context: ParseContext): void => {
+    shell.classes = getChildren(namespaceNode, "class").map((klass) => classFromNode(klass, false, context));
+    shell.interfaces = getChildren(namespaceNode, "interface").map((iface) => classFromNode(iface, true, context));
     shell.records = collectRecords(namespaceNode, context);
     shell.enums = collectEnums(namespaceNode);
-    shell.callbacks = childrenOf(namespaceNode, "callback").map((callback) => callbackFromNode(callback, context));
-    shell.functions = childrenOf(namespaceNode, "function").map((fn) => functionFromNode(fn, context));
-    shell.constants = childrenOf(namespaceNode, "constant").map((constant) => ({
+    shell.callbacks = getChildren(namespaceNode, "callback").map((callback) => callbackFromNode(callback, context));
+    shell.functions = getChildren(namespaceNode, "function").map((fn) => functionFromNode(fn, context));
+
+    shell.constants = getChildren(namespaceNode, "constant").map((constant) => ({
         name: nameAttr(constant),
-        doc: docOf(constant),
+        doc: getDoc(constant),
         value: attr(constant, "value") ?? "",
         type: typeRefFromNode(constant, context),
     }));
-    shell.aliases = childrenOf(namespaceNode, "alias").map((alias) => ({
+
+    shell.aliases = getChildren(namespaceNode, "alias").map((alias) => ({
         name: nameAttr(alias),
-        doc: docOf(alias),
+        doc: getDoc(alias),
         cType: attr(alias, "c:type"),
         target: typeRefFromNode(alias, context),
-        targetCType: attr(childOf(alias, "type"), "c:type"),
+        targetCType: attr(getChild(alias, "type"), "c:type"),
     }));
 };
 
@@ -111,13 +116,24 @@ const splitPrefixes = (raw: string | undefined): string[] =>
     (raw ?? "").split(",").filter((prefix) => prefix.length > 0);
 
 const collectRecords = (namespaceNode: RawNode, context: ParseContext): GirRecord[] => [
-    ...childrenOf(namespaceNode, "record").map((record) =>
+    ...getChildren(namespaceNode, "record").map((record) =>
         recordFromNode(record, isVtableRecord(record), false, context),
     ),
-    ...childrenOf(namespaceNode, "union").map((union) => recordFromNode(union, isVtableRecord(union), true, context)),
+    ...getChildren(namespaceNode, "union").map((union) => recordFromNode(union, isVtableRecord(union), true, context)),
 ];
 
 const collectEnums = (namespaceNode: RawNode): GirEnum[] => [
-    ...childrenOf(namespaceNode, "enumeration").map((enumeration) => enumFromNode(enumeration, "enumeration")),
-    ...childrenOf(namespaceNode, "bitfield").map((bitfield) => enumFromNode(bitfield, "bitfield")),
+    ...getChildren(namespaceNode, "enumeration").map((enumeration) => enumFromNode(enumeration, "enumeration")),
+    ...getChildren(namespaceNode, "bitfield").map((bitfield) => enumFromNode(bitfield, "bitfield")),
 ];
+
+export {
+    namespaceDirectory,
+    parseNamespaceHeader,
+    createNamespaceShell,
+    populateNamespaceBody,
+    type GirConstant,
+    type GirAlias,
+    type GirNamespace,
+    type NamespaceHeader,
+};

package/src/gir/nullable-overrides.ts

@@ -0,0 +1,5 @@
+const PARAMETERS_MISSING_NULLABLE_ANNOTATION: Map<string, string[]> = new Map([
+    ["gtk_fixed_layout_child_set_transform", ["transform"]],
+]);
+
+export { PARAMETERS_MISSING_NULLABLE_ANNOTATION };

package/src/gir/parameter.ts

@@ -1,23 +1,22 @@
-import { attr, attrBool, childOf, childrenOf, docOf, intAttr, nameAttr, parseEnumAttr, type RawNode } from "./parse.js";
 import type { ParseContext, TypeId } from "./type-id.js";
+import {
+    attr,
+    getChild,
+    getChildren,
+    getDoc,
+    intAttr,
+    isAttrTrue,
+    nameAttr,
+    parseEnumAttr,
+    type RawNode,
+} from "./parse.js";
 import { typeRefFromNode } from "./type-ref.js";
 
 type ParameterDirection = "in" | "out" | "inout";
-
-export type ParameterTransfer = "none" | "full" | "container";
-
+type ParameterTransfer = "none" | "full" | "container";
 type CallbackScope = "call" | "notified" | "async" | "forever";
 
-const DIRECTIONS: Set<ParameterDirection> = new Set(["in", "out", "inout"]);
-const TRANSFERS: Set<ParameterTransfer> = new Set(["none", "full", "container"]);
-const SCOPES: Set<CallbackScope> = new Set(["call", "notified", "async", "forever"]);
-
-export const transferOwnership = (node: RawNode): ParameterTransfer =>
-    parseEnumAttr(attr(node, "transfer-ownership"), TRANSFERS, "none", "transfer-ownership");
-
-const nullableAttr = (node: RawNode): boolean => attrBool(node, "nullable") || attrBool(node, "allow-none");
-
-export type GirParameter = {
+type GirParameter = {
     name: string;
     type: TypeId | undefined;
     direction: ParameterDirection;
@@ -31,61 +30,100 @@ export type GirParameter = {
     isVarargs: boolean;
 };
 
-export const parameterFromNode = (node: RawNode, context: ParseContext): GirParameter => ({
+type GirReturnValue = {
+    type: TypeId | undefined;
+    transferOwnership: ParameterTransfer;
+    nullable: boolean;
+    skip: boolean;
+};
+
+type GirCallable = {
+    name: string;
+    doc: string | undefined;
+    parameters: GirParameter[];
+    returnValue: GirReturnValue;
+    throws: boolean;
+    introspectable: boolean;
+};
+
+const DIRECTIONS: Set<ParameterDirection> = new Set(["in", "out", "inout"]);
+const TRANSFERS: Set<ParameterTransfer> = new Set(["none", "full", "container"]);
+const SCOPES: Set<CallbackScope> = new Set(["call", "notified", "async", "forever"]);
+
+const transferOwnership = (node: RawNode): ParameterTransfer =>
+    parseEnumAttr(attr(node, "transfer-ownership"), TRANSFERS, "none", "transfer-ownership");
+
+// `allow-none` is the legacy spelling of two different attributes: on an in-parameter it means the
+// value may be NULL (`nullable`), but on an out-parameter it means the caller may pass a NULL
+// location (`optional`). Folding it into `nullable` for an out-parameter would claim the returned
+// value can be null for the 494 out-parameters across the installed GIRs that only say `allow-none`.
+const isInDirection = (node: RawNode): boolean =>
+    parseEnumAttr(attr(node, "direction"), DIRECTIONS, "in", "direction") === "in";
+
+const hasNullableAttr = (node: RawNode): boolean =>
+    isAttrTrue(node, "nullable") || (isInDirection(node) && isAttrTrue(node, "allow-none"));
+
+const hasOptionalAttr = (node: RawNode): boolean =>
+    isAttrTrue(node, "optional") || (!isInDirection(node) && isAttrTrue(node, "allow-none"));
+
+const parameterFromNode = (node: RawNode, context: ParseContext): GirParameter => ({
     name: nameAttr(node),
     type: typeRefFromNode(node, context),
     direction: parseEnumAttr(attr(node, "direction"), DIRECTIONS, "in", "direction"),
     transferOwnership: transferOwnership(node),
-    nullable: nullableAttr(node),
-    optional: attrBool(node, "optional"),
-    callerAllocates: attrBool(node, "caller-allocates"),
+    nullable: hasNullableAttr(node),
+    optional: hasOptionalAttr(node),
+    callerAllocates: isAttrTrue(node, "caller-allocates"),
     scope: parseEnumAttr(attr(node, "scope"), SCOPES, undefined, "scope"),
     closureIndex: intAttr(node, "closure"),
     destroyIndex: intAttr(node, "destroy"),
-    isVarargs: childOf(node, "varargs") !== undefined,
+    isVarargs: getChild(node, "varargs") !== undefined,
 });
 
-export const isOutParameter = (parameter: GirParameter): boolean =>
+const isOutParameter = (parameter: GirParameter): boolean =>
     parameter.direction === "out" && !parameter.callerAllocates;
 
-export const isCallerAllocatedOut = (parameter: GirParameter): boolean =>
+const isCallerAllocatedOut = (parameter: GirParameter): boolean =>
     parameter.direction === "out" && parameter.callerAllocates;
 
-export const isInoutParameter = (parameter: GirParameter): boolean => parameter.direction === "inout";
-
-export type GirReturnValue = {
-    type: TypeId | undefined;
-    transferOwnership: ParameterTransfer;
-    nullable: boolean;
-    skip: boolean;
-};
+const isInoutParameter = (parameter: GirParameter): boolean => parameter.direction === "inout";
 
 const returnValueFromNode = (node: RawNode | undefined, context: ParseContext): GirReturnValue => {
     if (node === undefined) {
         return { type: undefined, transferOwnership: "none", nullable: false, skip: false };
     }
+
     return {
         type: typeRefFromNode(node, context),
         transferOwnership: transferOwnership(node),
-        nullable: nullableAttr(node),
-        skip: attrBool(node, "skip"),
+        nullable: hasNullableAttr(node),
+        skip: isAttrTrue(node, "skip"),
     };
 };
 
-export type GirSignal = {
-    name: string;
-    doc: string | undefined;
-    parameters: GirParameter[];
-    returnValue: GirReturnValue;
-};
+const parseCallable = (node: RawNode, context: ParseContext): GirCallable => {
+    const parametersNode = getChild(node, "parameters");
+    const parameterNodes = getChildren(parametersNode, "parameter");
 
-export const parseCallable = (node: RawNode, context: ParseContext): GirSignal => {
-    const parametersNode = childOf(node, "parameters");
-    const parameterNodes = childrenOf(parametersNode, "parameter");
     return {
         name: nameAttr(node),
-        doc: docOf(node),
+        doc: getDoc(node),
         parameters: parameterNodes.map((parameter) => parameterFromNode(parameter, context)),
-        returnValue: returnValueFromNode(childOf(node, "return-value"), context),
+        returnValue: returnValueFromNode(getChild(node, "return-value"), context),
+        throws: isAttrTrue(node, "throws"),
+        introspectable: isAttrTrue(node, "introspectable", true),
     };
 };
+
+export {
+    transferOwnership,
+    parameterFromNode,
+    isOutParameter,
+    isCallerAllocatedOut,
+    isInoutParameter,
+    parseCallable,
+    type ParameterTransfer,
+    type GirParameter,
+    type GirReturnValue,
+    type GirCallable,
+};

package/src/gir/parse.ts

@@ -1,9 +1,7 @@
 import { readFileSync } from "node:fs";
-import { XMLParser } from "fast-xml-parser";
+import { createXmlParser } from "../xml.js";
 
-export type RawNode = {
-    [attributeOrChild: string]: unknown;
-};
+type RawNode = Record<string, unknown>;
 
 const MULTI_TAGS: Set<string> = new Set([
     "include",
@@ -28,92 +26,149 @@ const MULTI_TAGS: Set<string> = new Set([
     "parameter",
 ]);
 
-export const GIR_CONSTRUCTOR_TAG = "gir-constructor";
-
+const GIR_CONSTRUCTOR_TAG = "gir-constructor";
 const RESERVED_TAG_RENAMES: Map<string, string> = new Map([["constructor", GIR_CONSTRUCTOR_TAG]]);
+const RENAMED_MULTI_TAGS: Set<string> = new Set([...MULTI_TAGS].map((tag) => renameReservedTag(tag)));
 
-const renameReservedTag = (tag: string): string => RESERVED_TAG_RENAMES.get(tag) ?? tag;
-
-const RENAMED_MULTI_TAGS: Set<string> = new Set([...MULTI_TAGS].map(renameReservedTag));
-
-const PARSER = new XMLParser({
-    ignoreAttributes: false,
-    attributeNamePrefix: "@_",
-    parseAttributeValue: false,
-    parseTagValue: false,
+const PARSER = createXmlParser({
     trimValues: true,
     transformTagName: renameReservedTag,
     isArray: (name) => RENAMED_MULTI_TAGS.has(name),
 });
 
-export const parseGirFile = (path: string): RawNode => {
-    const xml = readFileSync(path, "utf-8");
+function renameReservedTag(tag: string): string {
+    return RESERVED_TAG_RENAMES.get(tag) ?? tag;
+}
+
+const parseGirFile = (path: string): RawNode => {
+    const xml = readFileSync(path, "utf8");
+
     return PARSER.parse(xml) as RawNode;
 };
 
-export const attr = (node: RawNode | undefined, name: string): string | undefined => {
-    if (node === undefined) return undefined;
+const attr = (node: RawNode | undefined, name: string): string | undefined => {
+    if (node === undefined) {
+        return undefined;
+    }
+
     const value = node[`@_${name}`];
+
     return typeof value === "string" ? value : undefined;
 };
 
-export const attrBool = (node: RawNode | undefined, name: string, fallback = false): boolean => {
+const isAttrTrue = (node: RawNode | undefined, name: string, isTrueByDefault = false): boolean => {
     const value = attr(node, name);
-    if (value === undefined) return fallback;
+
+    if (value === undefined) {
+        return isTrueByDefault;
+    }
+
     return value === "1";
 };
 
-export const nameAttr = (node: RawNode): string => attr(node, "name") ?? "";
+const nameAttr = (node: RawNode): string => attr(node, "name") ?? "";
 
-export const intAttr = (node: RawNode, name: string): number | undefined => {
+const intAttr = (node: RawNode, name: string): number | undefined => {
     const raw = attr(node, name);
-    return raw === undefined ? undefined : Number.parseInt(raw, 10);
+
+    return raw === undefined ? undefined : Number(raw);
+};
+
+const enumMember = <T extends string>(raw: string, members: Set<T>, label: string): T => {
+    for (const member of members) {
+        if (member === raw) {
+            return member;
+        }
+    }
+
+    throw new Error(`Unknown ${label} value "${raw}"`);
 };
 
-export const parseEnumAttr = <T extends string, F extends T | undefined>(
+const parseEnumAttr = <T extends string, F extends T | undefined>(
     raw: string | undefined,
     members: Set<T>,
     fallback: F,
     label: string,
-): T | F => {
-    if (raw === undefined) return fallback;
-    for (const member of members) {
-        if (member === raw) return member;
+): T | F => (raw === undefined ? fallback : enumMember(raw, members, label));
+
+const getChildren = (node: RawNode | undefined, tag: string): RawNode[] => {
+    if (node === undefined) {
+        return [];
     }
-    throw new Error(`Unknown ${label} value "${raw}"`);
-};
 
-export const childrenOf = (node: RawNode | undefined, tag: string): RawNode[] => {
-    if (node === undefined) return [];
     const value = node[tag];
-    if (value === undefined) return [];
-    if (Array.isArray(value)) return value as RawNode[];
+
+    if (value === undefined) {
+        return [];
+    }
+
+    if (Array.isArray(value)) {
+        return value as RawNode[];
+    }
+
     return [value as RawNode];
 };
 
-export const childOf = (node: RawNode | undefined, tag: string): RawNode | undefined => {
-    if (node === undefined) return undefined;
+const getChild = (node: RawNode | undefined, tag: string): RawNode | undefined => {
+    if (node === undefined) {
+        return undefined;
+    }
+
     const value = node[tag];
-    if (value === undefined) return undefined;
+
+    if (value === undefined) {
+        return undefined;
+    }
+
     if (Array.isArray(value)) {
         return value.length === 0 ? undefined : (value[0] as RawNode);
     }
+
     return value as RawNode;
 };
 
 const normalizeDoc = (text: string): string | undefined => {
     const trimmed = text.trim();
+
     return trimmed.length === 0 ? undefined : trimmed;
 };
 
-export const docOf = (node: RawNode | undefined): string | undefined => {
-    if (node === undefined) return undefined;
-    const raw = node.doc;
-    const value = Array.isArray(raw) ? raw[0] : raw;
-    if (typeof value === "string") return normalizeDoc(value);
-    if (value !== null && typeof value === "object") {
-        const text = (value as RawNode)["#text"];
-        if (typeof text === "string") return normalizeDoc(text);
+const firstDocValue = (raw: unknown): unknown => (Array.isArray(raw) ? raw[0] : raw);
+
+const docTextFromObject = (value: object): string | undefined => {
+    const text = (value as RawNode)["#text"];
+
+    return typeof text === "string" ? normalizeDoc(text) : undefined;
+};
+
+const getDoc = (node: RawNode | undefined): string | undefined => {
+    if (node === undefined) {
+        return undefined;
+    }
+
+    const value = firstDocValue(node.doc);
+
+    if (typeof value === "string") {
+        return normalizeDoc(value);
+    }
+
+    if (value === null || typeof value !== "object") {
+        return undefined;
     }
-    return undefined;
+
+    return docTextFromObject(value);
+};
+
+export {
+    GIR_CONSTRUCTOR_TAG,
+    parseGirFile,
+    attr,
+    isAttrTrue,
+    nameAttr,
+    intAttr,
+    parseEnumAttr,
+    getChildren,
+    getChild,
+    getDoc,
+    type RawNode,
 };

package/src/gir/primitives.ts

@@ -1,24 +1,24 @@
-export type PrimitiveCategory =
-    | "void"
-    | "boolean"
-    | "int8"
-    | "uint8"
-    | "int16"
-    | "uint16"
-    | "int32"
-    | "uint32"
-    | "int64"
-    | "uint64"
-    | "bigint64"
-    | "biguint64"
-    | "gtype"
-    | "float32"
-    | "float64"
-    | "string"
-    | "unichar"
-    | "pointer";
+type PrimitiveCategory =
+    | "void" |
+    "boolean" |
+    "int8" |
+    "uint8" |
+    "int16" |
+    "uint16" |
+    "int32" |
+    "uint32" |
+    "int64" |
+    "uint64" |
+    "bigint64" |
+    "biguint64" |
+    "gtype" |
+    "float32" |
+    "float64" |
+    "string" |
+    "unichar" |
+    "pointer";
 
-export const PRIMITIVE_SIZE: Record<PrimitiveCategory, number> = {
+const PRIMITIVE_SIZE: Record<PrimitiveCategory, number> = {
     void: 0,
     boolean: 4,
     int8: 1,
@@ -91,9 +91,7 @@ const PRIMITIVE_BY_NAME: Map<string, PrimitiveCategory> = new Map([
     ["gconstpointer", "pointer"],
 ] as const);
 
-export const primitiveCategory = (name: string): PrimitiveCategory | undefined => PRIMITIVE_BY_NAME.get(name);
-
-export const PRIMITIVE_TS_TYPE: Record<PrimitiveCategory, string> = {
+const PRIMITIVE_TS_TYPE: Record<PrimitiveCategory, string> = {
     void: "void",
     boolean: "boolean",
     int8: "number",
@@ -113,3 +111,7 @@ export const PRIMITIVE_TS_TYPE: Record<PrimitiveCategory, string> = {
     unichar: "string",
     pointer: "number",
 };
+
+const primitiveCategory = (name: string): PrimitiveCategory | undefined => PRIMITIVE_BY_NAME.get(name);
+
+export { PRIMITIVE_SIZE, PRIMITIVE_TS_TYPE, primitiveCategory, type PrimitiveCategory };

package/src/gir/property.ts

@@ -1,9 +1,9 @@
-import { type ParameterTransfer, transferOwnership } from "./parameter.js";
-import { attr, attrBool, docOf, nameAttr, type RawNode } from "./parse.js";
 import type { ParseContext, TypeId } from "./type-id.js";
+import { type ParameterTransfer, transferOwnership } from "./parameter.js";
+import { attr, getDoc, isAttrTrue, nameAttr, type RawNode } from "./parse.js";
 import { typeRefFromNode } from "./type-ref.js";
 
-export type GirProperty = {
+type GirProperty = {
     name: string;
     doc: string | undefined;
     type: TypeId | undefined;
@@ -18,20 +18,22 @@ export type GirProperty = {
     defaultValue: string | undefined;
 };
 
-export const isConstructableProperty = (property: GirProperty): boolean =>
+const isConstructableProperty = (property: GirProperty): boolean =>
     property.writable || property.construct || property.constructOnly;
 
-export const propertyFromNode = (node: RawNode, context: ParseContext): GirProperty => ({
+const propertyFromNode = (node: RawNode, context: ParseContext): GirProperty => ({
     name: nameAttr(node),
-    doc: docOf(node),
+    doc: getDoc(node),
     type: typeRefFromNode(node, context),
-    readable: attrBool(node, "readable", true),
-    writable: attrBool(node, "writable"),
-    construct: attrBool(node, "construct"),
-    constructOnly: attrBool(node, "construct-only"),
-    introspectable: attrBool(node, "introspectable", true),
+    readable: isAttrTrue(node, "readable", true),
+    writable: isAttrTrue(node, "writable"),
+    construct: isAttrTrue(node, "construct"),
+    constructOnly: isAttrTrue(node, "construct-only"),
+    introspectable: isAttrTrue(node, "introspectable", true),
     transferOwnership: transferOwnership(node),
     getter: attr(node, "getter"),
     setter: attr(node, "setter"),
     defaultValue: attr(node, "default-value"),
 });
+
+export { isConstructableProperty, propertyFromNode, type GirProperty };