@gtkx/ffi 0.1.12 → 0.1.14

package/dist/codegen/ffi-generator.d.ts

@@ -17,6 +17,7 @@ export declare class CodeGenerator {
     private usesAlloc;
     private usesNativeError;
     private usesWrapPtr;
+    private usesSignalMeta;
     private usedEnums;
     private usedRecords;
     private usedExternalTypes;
@@ -46,6 +47,7 @@ export declare class CodeGenerator {
     private getAncestors;
     private classImports;
     private collectParentMethodNames;
+    private collectAllSignals;
     private generateConstructors;
     private generateConstructor;
     private generateCreatePtr;

package/dist/codegen/ffi-generator.js

@@ -85,6 +85,9 @@ const METHOD_RENAMES = new Map([
     ["SocketClient", new Map([["connect", "connectTo"]])],
     ["SocketConnection", new Map([["connect", "connectTo"]])],
     ["Socket", new Map([["connect", "connectTo"]])],
+    ["Cancellable", new Map([["connect", "connectCallback"]])],
+    ["GutterRenderer", new Map([["activate", "activateRenderer"]])],
+    ["GutterRendererText", new Map([["measure", "measureText"]])],
 ]);
 const CLASS_RENAMES = new Map([["Error", "GError"]]);
 const getRenamedMethod = (namespace, className, methodName) => {
@@ -216,6 +219,7 @@ export class CodeGenerator {
     usesAlloc = false;
     usesNativeError = false;
     usesWrapPtr = false;
+    usesSignalMeta = false;
     usedEnums = new Set();
     usedRecords = new Set();
     usedExternalTypes = new Map();
@@ -357,6 +361,7 @@ export class CodeGenerator {
         this.usesAlloc = false;
         this.usesNativeError = false;
         this.usesWrapPtr = false;
+        this.usesSignalMeta = false;
         this.usedEnums.clear();
         this.usedRecords.clear();
         this.usedExternalTypes.clear();
@@ -429,11 +434,21 @@ export class CodeGenerator {
         if (interfaceMethods.length > 0) {
             sections.push(this.generateMethods(interfaceMethods, sharedLibrary, className));
         }
-        if (cls.signals.length > 0) {
+        let signalMetaConstant = "";
+        const { signals: allSignals, hasCrossNamespaceParent } = this.collectAllSignals(cls, classMap);
+        if (allSignals.length > 0 && !hasCrossNamespaceParent) {
             const hasConnectMethod = cls.methods.some((m) => toCamelCase(m.name) === "connect");
-            sections.push(this.generateSignalConnect(sharedLibrary, cls.signals, hasConnectMethod, classMap));
+            const signalConnect = this.generateSignalConnect(sharedLibrary, allSignals, hasConnectMethod, classMap, className);
+            signalMetaConstant = signalConnect.moduleLevel;
+            sections.push(signalConnect.method);
         }
         sections.push("}");
+        if (signalMetaConstant) {
+            const classDefIndex = sections.findIndex((s) => s.startsWith("export class "));
+            if (classDefIndex !== -1) {
+                sections.splice(classDefIndex, 0, signalMetaConstant);
+            }
+        }
         const imports = this.generateImports(className, parentInfo.hasParent && !parentInfo.isCrossNamespace ? parentInfo.className : undefined, parentInfo.isCrossNamespace ? parentInfo.namespace : undefined);
         return this.formatCode(imports + sections.join("\n"));
     }
@@ -555,6 +570,30 @@ export class CodeGenerator {
         }
         return names;
     }
+    collectAllSignals(cls, classMap) {
+        const allSignals = [...cls.signals];
+        const seenNames = new Set(cls.signals.map((s) => s.name));
+        if (cls.parent?.includes(".")) {
+            return { signals: allSignals, hasCrossNamespaceParent: true };
+        }
+        let current = cls.parent ? classMap.get(cls.parent) : undefined;
+        while (current) {
+            if (current.signals.length > 0 && current.parent?.includes(".")) {
+                return { signals: allSignals, hasCrossNamespaceParent: true };
+            }
+            for (const signal of current.signals) {
+                if (!seenNames.has(signal.name)) {
+                    allSignals.push(signal);
+                    seenNames.add(signal.name);
+                }
+            }
+            if (current.parent?.includes(".")) {
+                break;
+            }
+            current = current.parent ? classMap.get(current.parent) : undefined;
+        }
+        return { signals: allSignals, hasCrossNamespaceParent: false };
+    }
     generateConstructors(cls, _sharedLibrary, hasParent) {
         const mainConstructor = cls.constructors.find((c) => !c.parameters.some(isVararg));
         const sections = [];
@@ -647,6 +686,7 @@ export class CodeGenerator {
             : "";
         const callArgs = this.generateCallArguments(mainConstructor.parameters);
         const override = hasParent ? "override " : "";
+        const borrowed = mainConstructor.returnType.transferOwnership !== "full";
         return `  protected ${override}createPtr(${arrayParamName}: unknown[]): unknown {
 ${destructuring}    return call(
       "${sharedLibrary}",
@@ -654,7 +694,7 @@ ${destructuring}    return call(
       [
 ${callArgs}
       ],
-      { type: "gobject", borrowed: true }
+      { type: "gobject", borrowed: ${borrowed} }
     );
   }
 `;
@@ -671,6 +711,7 @@ ${callArgs}
         const params = this.generateParameterList(ctor.parameters);
         const args = this.generateCallArguments(ctor.parameters);
         const ctorDoc = formatMethodDoc(ctor.doc, ctor.parameters);
+        const borrowed = ctor.returnType.transferOwnership !== "full";
         this.usesWrapPtr = true;
         return `${ctorDoc}  static ${methodName}(${params}): ${className} {
     const ptr = call(
@@ -679,7 +720,7 @@ ${callArgs}
       [
 ${args}
       ],
-      { type: "gobject", borrowed: true }
+      { type: "gobject", borrowed: ${borrowed} }
     );
     return wrapPtr(ptr, ${className});
   }
@@ -830,8 +871,9 @@ ${allArgs ? `${allArgs},` : ""}
         const returnTypeMapping = this.typeMapper.mapType(finishMethod.returnType, true);
         const mainReturnType = returnTypeMapping.ts;
         const hasMainReturn = mainReturnType !== "void";
+        const isNullable = finishMethod.returnType.nullable === true;
         this.addGioImport = true;
-        const promiseType = this.buildAsyncReturnType(hasMainReturn, mainReturnType, outputParams);
+        const promiseType = this.buildAsyncReturnType(hasMainReturn, mainReturnType, outputParams, isNullable);
         const lines = [];
         lines.push(`  /**`);
         lines.push(`   * Promise-based version of ${methodName}.`);
@@ -844,19 +886,22 @@ ${allArgs ? `${allArgs},` : ""}
         lines.push(`   */`);
         lines.push(`  ${methodName}(${params}): Promise<${promiseType}> {`);
         lines.push(`    return new Promise((resolve, reject) => {`);
-        const callArgs = this.buildAsyncCallArgs(method, finishMethod, outputParams, sharedLibrary);
+        const callArgs = this.buildAsyncCallArgs(method, finishMethod, outputParams, sharedLibrary, isNullable);
         lines.push(callArgs);
         lines.push(`    });`);
         lines.push(`  }`);
         return `${lines.join("\n")}\n`;
     }
-    buildAsyncReturnType(hasMainReturn, mainReturnType, outputParams) {
+    buildAsyncReturnType(hasMainReturn, mainReturnType, outputParams, isNullable = false) {
         if (outputParams.length === 0) {
-            return hasMainReturn ? mainReturnType : "void";
+            if (!hasMainReturn)
+                return "void";
+            return isNullable ? `${mainReturnType} | null` : mainReturnType;
         }
         const outputTypes = [];
         if (hasMainReturn) {
-            outputTypes.push(`result: ${mainReturnType}`);
+            const returnType = isNullable ? `${mainReturnType} | null` : mainReturnType;
+            outputTypes.push(`result: ${returnType}`);
         }
         for (const param of outputParams) {
             const paramName = toValidIdentifier(toCamelCase(param.name));
@@ -869,7 +914,7 @@ ${allArgs ? `${allArgs},` : ""}
         }
         return `{ ${outputTypes.join("; ")} }`;
     }
-    buildAsyncCallArgs(method, finishMethod, outputParams, sharedLibrary) {
+    buildAsyncCallArgs(method, finishMethod, outputParams, sharedLibrary, isNullable = false) {
         const returnTypeMapping = this.typeMapper.mapType(finishMethod.returnType, true);
         const hasMainReturn = returnTypeMapping.ts !== "void";
         const needsObjectWrap = (returnTypeMapping.ffi.type === "gobject" || returnTypeMapping.ffi.type === "boxed") &&
@@ -935,7 +980,9 @@ ${allArgs ? `${allArgs},` : ""}
             if (hasMainReturn) {
                 if (needsObjectWrap) {
                     this.usesWrapPtr = true;
-                    lines.push(`          if (ptr === null) { resolve(null as unknown as ${finishReturnType.ts}); return; }`);
+                    if (isNullable) {
+                        lines.push(`          if (ptr === null) { resolve(null); return; }`);
+                    }
                     lines.push(`          resolve(wrapPtr(ptr, ${finishReturnType.ts}));`);
                 }
                 else {
@@ -951,7 +998,12 @@ ${allArgs ? `${allArgs},` : ""}
             if (hasMainReturn) {
                 if (needsObjectWrap) {
                     this.usesWrapPtr = true;
-                    lines.push(`          const result = (ptr === null ? null : wrapPtr(ptr, ${finishReturnType.ts})) as ${finishReturnType.ts};`);
+                    if (isNullable) {
+                        lines.push(`          const result = (ptr === null ? null : wrapPtr(ptr, ${finishReturnType.ts})) as ${finishReturnType.ts} | null;`);
+                    }
+                    else {
+                        lines.push(`          const result = wrapPtr(ptr, ${finishReturnType.ts});`);
+                    }
                 }
                 resolveFields.push("result");
             }
@@ -979,7 +1031,7 @@ ${allArgs ? `${allArgs},` : ""}
             lines.push(`${asyncCallArgs},`);
         }
         lines.push(`          {`);
-        lines.push(`            type: { type: "asyncCallback", sourceType: { type: "gobject", borrowed: true }, resultType: { type: "gobject", borrowed: true } },`);
+        lines.push(`            type: { type: "callback", trampoline: "asyncReady", sourceType: { type: "gobject", borrowed: true }, resultType: { type: "gobject", borrowed: true } },`);
         lines.push(`            value: callback,`);
         lines.push(`          },`);
         lines.push(`        ],`);
@@ -1016,12 +1068,14 @@ ${allArgs ? `${allArgs},` : ""}
         }
         const params = this.generateParameterList(method.parameters);
         const returnTypeMapping = this.typeMapper.mapType(method.returnType, true);
-        const tsReturnType = returnTypeMapping.ts === "void" ? "void" : returnTypeMapping.ts;
+        const isNullable = method.returnType.nullable === true;
+        const baseReturnType = returnTypeMapping.ts === "void" ? "void" : returnTypeMapping.ts;
+        const tsReturnType = isNullable && baseReturnType !== "void" ? `${baseReturnType} | null` : baseReturnType;
         const returnTypeAnnotation = tsReturnType !== "void" ? `: ${tsReturnType}` : "";
         const hasResultParam = method.parameters.some((p) => toValidIdentifier(toCamelCase(p.name)) === "result");
         const resultVarName = hasResultParam ? "_result" : "result";
         const needsObjectWrap = (returnTypeMapping.ffi.type === "gobject" || returnTypeMapping.ffi.type === "boxed") &&
-            tsReturnType !== "unknown" &&
+            baseReturnType !== "unknown" &&
             returnTypeMapping.kind !== "interface";
         const hasReturnValue = returnTypeMapping.ts !== "void";
         const lines = [];
@@ -1053,13 +1107,15 @@ ${allArgs ? `${allArgs},` : ""}
             if (method.throws) {
                 lines.push(this.generateErrorCheck());
             }
-            lines.push(`    if (ptr === null) return null as unknown as ${tsReturnType};`);
+            if (isNullable) {
+                lines.push(`    if (ptr === null) return null;`);
+            }
             if (isCyclic) {
-                lines.push(`    return { ptr } as unknown as ${tsReturnType};`);
+                lines.push(`    return { ptr } as unknown as ${baseReturnType};`);
             }
             else {
                 this.usesWrapPtr = true;
-                lines.push(`    return wrapPtr(ptr, ${tsReturnType});`);
+                lines.push(`    return wrapPtr(ptr, ${baseReturnType});`);
             }
         }
         else {
@@ -1110,7 +1166,7 @@ ${allArgs ? `${allArgs},` : ""}
         }
         return undefined;
     }
-    generateSignalConnect(sharedLibrary, signals, hasConnectMethod, classMap) {
+    generateSignalConnect(sharedLibrary, signals, hasConnectMethod, classMap, className) {
         const methodName = hasConnectMethod ? "on" : "connect";
         const savedEnumCallback = this.typeMapper.getEnumUsageCallback();
         const savedRecordCallback = this.typeMapper.getRecordUsageCallback();
@@ -1121,10 +1177,10 @@ ${allArgs ? `${allArgs},` : ""}
         const signalMetadata = signals.map((signal) => {
             const paramEntries = (signal.parameters ?? []).map((param) => {
                 const ffiType = JSON.stringify(this.typeMapper.mapType(param.type).ffi);
-                const className = this.extractSignalParamClass(param, classMap);
-                if (className) {
-                    this.signalClasses.add(className);
-                    return `{ type: ${ffiType}, cls: ${className} }`;
+                const signalParamClass = this.extractSignalParamClass(param, classMap);
+                if (signalParamClass) {
+                    this.signalClasses.add(signalParamClass);
+                    return `{ type: ${ffiType}, cls: ${signalParamClass} }`;
                 }
                 return `{ type: ${ffiType} }`;
             });
@@ -1136,33 +1192,61 @@ ${allArgs ? `${allArgs},` : ""}
             const key = `${usage.namespace}.${usage.transformedName}`;
             this.usedExternalTypes.set(key, usage);
         });
-        this.typeMapper.setSameNamespaceClassUsageCallback((className, originalName) => {
-            this.usedSameNamespaceClasses.set(className, originalName);
+        this.typeMapper.setSameNamespaceClassUsageCallback((clsName, originalName) => {
+            this.usedSameNamespaceClasses.set(clsName, originalName);
         });
+        const signalOverloads = signals.map((signal) => {
+            const signalParams = signal.parameters ?? [];
+            const handlerParams = [`self: ${className}`];
+            for (const param of signalParams) {
+                const paramName = toValidIdentifier(toCamelCase(param.name));
+                const signalParamClass = this.extractSignalParamClass(param, classMap);
+                const paramType = signalParamClass ?? this.typeMapper.mapType(param.type).ts;
+                handlerParams.push(`${paramName}: ${paramType}`);
+            }
+            const returnType = signal.returnType ? this.typeMapper.mapType(signal.returnType).ts : "void";
+            return `  ${methodName}(signal: "${signal.name}", handler: (${handlerParams.join(", ")}) => ${returnType}, after?: boolean): number;`;
+        });
+        const hasNotifySignal = signals.some((s) => s.name === "notify");
+        if (!hasNotifySignal && this.options.namespace !== "GObject") {
+            signalOverloads.push(`  ${methodName}(signal: "notify", handler: (self: ${className}, pspec: GObject.ParamSpec) => void, after?: boolean): number;`);
+            this.usedExternalTypes.set("GObject.ParamSpec", {
+                namespace: "GObject",
+                name: "ParamSpec",
+                transformedName: "ParamSpec",
+                kind: "class",
+            });
+        }
+        signalOverloads.push(`  ${methodName}(signal: string, handler: (...args: any[]) => any, after?: boolean): number;`);
         this.usesType = true;
         if (signalMetadata.length > 0) {
             this.usesWrapPtr = true;
+            this.usesSignalMeta = true;
         }
+        const moduleLevel = signalMetadata.length > 0
+            ? `const SIGNAL_META: SignalMeta = {\n${signalMetadata.join(",\n")}\n};\n`
+            : "";
         const signalMapCode = signalMetadata.length > 0
-            ? `const signalMeta: Record<string, { type: Type; cls?: { prototype: object } }[]> = {\n${signalMetadata.join(",\n")}\n  };
-    const meta = signalMeta[signal];
-    const selfType: Type = { type: "gobject", borrowed: false };
+            ? `const meta = SIGNAL_META[signal];
+    const selfType: Type = { type: "gobject", borrowed: true };
     const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];`
-            : `const meta = undefined;\n    const selfType: Type = { type: "gobject", borrowed: false };\n    const argTypes = [selfType];`;
+            : `const meta = undefined;\n    const selfType: Type = { type: "gobject", borrowed: true };\n    const argTypes = [selfType];`;
         const wrapperCode = `const wrappedHandler = (...args: unknown[]) => {
+      const self = wrapPtr(args[0], ${className});
       const signalArgs = args.slice(1);
-      if (!meta) return handler(...signalArgs);
+      if (!meta) return handler(self, ...signalArgs);
       const wrapped = meta.map((m, i) => {
         if (m.cls && signalArgs[i] != null) {
           return wrapPtr(signalArgs[i], m.cls);
         }
         return signalArgs[i];
       });
-      return handler(...wrapped);
+      return handler(self, ...wrapped);
     };`;
-        return `  ${methodName}(
+        const overloadsSection = signalOverloads.length > 0 ? `${signalOverloads.join("\n")}\n` : "";
+        const method = `${overloadsSection}  ${methodName}(
     signal: string,
-    handler: (...args: unknown[]) => unknown,
+    handler: (...args: any[]) => any,
     after = false
   ): number {
     ${signalMapCode}
@@ -1180,6 +1264,7 @@ ${allArgs ? `${allArgs},` : ""}
     ) as number;
   }
 `;
+        return { moduleLevel, method };
     }
     async generateInterface(iface, sharedLibrary, _classMap) {
         this.resetState();
@@ -1539,7 +1624,10 @@ ${args}
         const funcName = toValidIdentifier(toCamelCase(func.name));
         const params = this.generateParameterList(func.parameters);
         const returnTypeMapping = this.typeMapper.mapType(func.returnType, true);
-        const tsReturnType = returnTypeMapping.ts === "void" ? "" : `: ${returnTypeMapping.ts}`;
+        const isNullable = func.returnType.nullable === true;
+        const baseReturnType = returnTypeMapping.ts;
+        const fullReturnType = isNullable && baseReturnType !== "void" ? `${baseReturnType} | null` : baseReturnType;
+        const tsReturnType = fullReturnType === "void" ? "" : `: ${fullReturnType}`;
         const hasResultParam = func.parameters.some((p) => toValidIdentifier(toCamelCase(p.name)) === "result");
         const resultVarName = hasResultParam ? "_result" : "result";
         const needsObjectWrap = (returnTypeMapping.ffi.type === "gobject" || returnTypeMapping.ffi.type === "boxed") &&
@@ -1566,8 +1654,10 @@ ${allArgs ? `${allArgs},` : ""}
             if (func.throws) {
                 lines.push(this.generateErrorCheck(""));
             }
-            lines.push(`  if (ptr === null) return null as unknown as ${returnTypeMapping.ts};`);
-            lines.push(`  return wrapPtr(ptr, ${returnTypeMapping.ts});`);
+            if (isNullable) {
+                lines.push(`  if (ptr === null) return null;`);
+            }
+            lines.push(`  return wrapPtr(ptr, ${baseReturnType});`);
         }
         else {
             const callPrefix = func.throws
@@ -1620,7 +1710,8 @@ ${allArgs ? `${allArgs},` : ""}
             const mapped = this.typeMapper.mapParameter(param);
             const paramName = toValidIdentifier(toCamelCase(param.name));
             const isOptional = makeAllOptional || this.typeMapper.isNullable(param);
-            const paramStr = `${paramName}${isOptional ? "?" : ""}: ${mapped.ts}`;
+            const typeStr = isOptional ? `${mapped.ts} | null` : mapped.ts;
+            const paramStr = `${paramName}${isOptional ? "?" : ""}: ${typeStr}`;
             (isOptional ? optional : required).push(paramStr);
         }
         return [...required, ...optional].join(", ");
@@ -1653,6 +1744,9 @@ ${indent}  }`;
         if (type.type === "float") {
             return `{ type: "float", size: ${type.size} }`;
         }
+        if (type.type === "string") {
+            return type.borrowed ? `{ type: "string", borrowed: true }` : `{ type: "string" }`;
+        }
         if (type.type === "gobject") {
             return type.borrowed ? `{ type: "gobject", borrowed: true }` : `{ type: "gobject" }`;
         }
@@ -1669,8 +1763,18 @@ ${indent}  }`;
         if (type.type === "array" && type.itemType) {
             return `{ type: "array", itemType: ${this.generateTypeDescriptor(type.itemType)} }`;
         }
-        if (type.type === "asyncCallback" && type.sourceType && type.resultType) {
-            return `{ type: "asyncCallback", sourceType: ${this.generateTypeDescriptor(type.sourceType)}, resultType: ${this.generateTypeDescriptor(type.resultType)} }`;
+        if (type.type === "callback") {
+            const parts = [`type: "callback"`];
+            if (type.trampoline) {
+                parts.push(`trampoline: "${type.trampoline}"`);
+            }
+            if (type.sourceType) {
+                parts.push(`sourceType: ${this.generateTypeDescriptor(type.sourceType)}`);
+            }
+            if (type.resultType) {
+                parts.push(`resultType: ${this.generateTypeDescriptor(type.resultType)}`);
+            }
+            return `{ ${parts.join(", ")} }`;
         }
         return `{ type: "${type.type}" }`;
     }
@@ -1695,6 +1799,8 @@ ${indent}  }`;
         const ffiImports = [];
         if (this.usesNativeError)
             ffiImports.push("NativeError");
+        if (this.usesSignalMeta)
+            ffiImports.push("SignalMeta");
         if (this.usesWrapPtr)
             ffiImports.push("wrapPtr");
         if (ffiImports.length > 0) {

package/dist/generated/gdk/app-launch-context.d.ts

@@ -5,7 +5,7 @@ export declare class AppLaunchContext extends Gio.AppLaunchContext {
     protected createPtr(_args: unknown[]): unknown;
     getGdkDisplay(): Display;
     setDesktop(desktop: number): void;
-    setIcon(icon?: Gio.Icon): void;
-    setIconName(iconName?: string): void;
+    setIcon(icon?: Gio.Icon | null): void;
+    setIconName(iconName?: string | null): void;
     setTimestamp(timestamp: number): void;
 }

package/dist/generated/gdk/app-launch-context.js

@@ -24,8 +24,6 @@ export class AppLaunchContext extends Gio.AppLaunchContext {
                 value: this.ptr,
             },
         ], { type: "gobject", borrowed: true });
-        if (ptr === null)
-            return null;
         return wrapPtr(ptr, Display);
     }
     setDesktop(desktop) {

package/dist/generated/gdk/cairo-context.d.ts

@@ -3,5 +3,5 @@ import { DrawContext } from "./draw-context.js";
 export declare class CairoContext extends DrawContext {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
-    cairoCreate(): cairo.Context;
+    cairoCreate(): cairo.Context | null;
 }

package/dist/generated/gdk/cicp-params.js

@@ -9,7 +9,7 @@ export class CicpParams extends GObject.GObject {
     createPtr(_args) {
         return call("libgtk-4.so.1", "gdk_cicp_params_new", [], {
             type: "gobject",
-            borrowed: true,
+            borrowed: false,
         });
     }
     buildColorState() {
@@ -39,8 +39,6 @@ export class CicpParams extends GObject.GObject {
         if (error.value !== null) {
             throw new NativeError(error.value);
         }
-        if (ptr === null)
-            return null;
         return wrapPtr(ptr, ColorState);
     }
     getColorPrimaries() {

package/dist/generated/gdk/clipboard.d.ts

@@ -8,16 +8,15 @@ import * as Gio from "../gio/index.js";
 export declare class Clipboard extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
-    getContent(): ContentProvider;
+    getContent(): ContentProvider | null;
     getDisplay(): Display;
     getFormats(): ContentFormats;
     isLocal(): boolean;
-    readFinish(result: Gio.AsyncResult, outMimeType?: Ref<string>): Gio.InputStream;
-    readTextFinish(result: Gio.AsyncResult): string;
-    readTextureFinish(result: Gio.AsyncResult): Texture;
+    readFinish(result: Gio.AsyncResult, outMimeType?: Ref<string> | null): Gio.InputStream | null;
+    readTextFinish(result: Gio.AsyncResult): string | null;
+    readTextureFinish(result: Gio.AsyncResult): Texture | null;
     readValueFinish(result: Gio.AsyncResult): GObject.Value;
-    setContent(provider?: ContentProvider): boolean;
+    setContent(provider?: ContentProvider | null): boolean;
     setValue(value: GObject.Value): void;
     storeFinish(result: Gio.AsyncResult): boolean;
-    connect(signal: string, handler: (...args: unknown[]) => unknown, after?: boolean): number;
 }

package/dist/generated/gdk/clipboard.js

@@ -39,8 +39,6 @@ export class Clipboard extends GObject.GObject {
                 value: this.ptr,
             },
         ], { type: "gobject", borrowed: true });
-        if (ptr === null)
-            return null;
         return wrapPtr(ptr, Display);
     }
     getFormats() {
@@ -55,8 +53,6 @@ export class Clipboard extends GObject.GObject {
             innerType: "GdkContentFormats",
             lib: "libgtk-4.so.1",
         });
-        if (ptr === null)
-            return null;
         return wrapPtr(ptr, ContentFormats);
     }
     isLocal() {
@@ -190,8 +186,6 @@ export class Clipboard extends GObject.GObject {
         if (error.value !== null) {
             throw new NativeError(error.value);
         }
-        if (ptr === null)
-            return null;
         return wrapPtr(ptr, GObject.Value);
     }
     setContent(provider) {
@@ -246,30 +240,4 @@ export class Clipboard extends GObject.GObject {
         }
         return _result;
     }
-    connect(signal, handler, after = false) {
-        const signalMeta = {
-            changed: [],
-        };
-        const meta = signalMeta[signal];
-        const selfType = { type: "gobject", borrowed: false };
-        const argTypes = meta ? [selfType, ...meta.map((m) => m.type)] : [selfType];
-        const wrappedHandler = (...args) => {
-            const signalArgs = args.slice(1);
-            if (!meta)
-                return handler(...signalArgs);
-            const wrapped = meta.map((m, i) => {
-                if (m.cls && signalArgs[i] != null) {
-                    return wrapPtr(signalArgs[i], m.cls);
-                }
-                return signalArgs[i];
-            });
-            return handler(...wrapped);
-        };
-        return call("libgtk-4.so.1", "g_signal_connect_closure", [
-            { type: { type: "gobject" }, value: this.ptr },
-            { type: { type: "string" }, value: signal },
-            { type: { type: "callback", argTypes }, value: wrappedHandler },
-            { type: { type: "boolean" }, value: after },
-        ], { type: "int", size: 64, unsigned: true });
-    }
 }

package/dist/generated/gdk/color-state.d.ts

@@ -9,7 +9,7 @@ export declare class ColorState {
     static getRec2100Pq(): ColorState;
     static getSrgb(): ColorState;
     static getSrgbLinear(): ColorState;
-    createCicpParams(): CicpParams;
+    createCicpParams(): CicpParams | null;
     equal(other: ColorState): boolean;
     equivalent(other: ColorState): boolean;
     ref(): ColorState;

package/dist/generated/gdk/color-state.js

@@ -118,8 +118,6 @@ export class ColorState {
             innerType: "GdkColorState",
             lib: "libgtk-4.so.1",
         });
-        if (ptr === null)
-            return null;
         return wrapPtr(ptr, ColorState);
     }
     unref() {

package/dist/generated/gdk/content-deserializer.d.ts

@@ -4,15 +4,15 @@ import * as Gio from "../gio/index.js";
 export declare class ContentDeserializer extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
-    getCancellable(): Gio.Cancellable;
+    getCancellable(): Gio.Cancellable | null;
     getGtype(): number;
     getInputStream(): Gio.InputStream;
     getMimeType(): string;
     getPriority(): number;
-    getTaskData(): unknown;
-    getUserData(): unknown;
+    getTaskData(): number | null;
+    getUserData(): number | null;
     getValue(): GObject.Value;
     returnError(error: GLib.GError): void;
     returnSuccess(): void;
-    setTaskData(notify: unknown, data?: unknown): void;
+    setTaskData(notify: () => void, data?: number | null): void;
 }

package/dist/generated/gdk/content-deserializer.js

@@ -39,8 +39,6 @@ export class ContentDeserializer extends GObject.GObject {
                 value: this.ptr,
             },
         ], { type: "gobject", borrowed: true });
-        if (ptr === null)
-            return null;
         return wrapPtr(ptr, Gio.InputStream);
     }
     getMimeType() {
@@ -49,7 +47,7 @@ export class ContentDeserializer extends GObject.GObject {
                 type: { type: "gobject" },
                 value: this.ptr,
             },
-        ], { type: "string" });
+        ], { type: "string", borrowed: true });
     }
     getPriority() {
         return call("libgtk-4.so.1", "gdk_content_deserializer_get_priority", [
@@ -65,7 +63,7 @@ export class ContentDeserializer extends GObject.GObject {
                 type: { type: "gobject" },
                 value: this.ptr,
             },
-        ], { type: "gobject" });
+        ], { type: "int", size: 64, unsigned: true });
     }
     getUserData() {
         return call("libgtk-4.so.1", "gdk_content_deserializer_get_user_data", [
@@ -73,7 +71,7 @@ export class ContentDeserializer extends GObject.GObject {
                 type: { type: "gobject" },
                 value: this.ptr,
             },
-        ], { type: "gobject" });
+        ], { type: "int", size: 64, unsigned: true });
     }
     getValue() {
         const ptr = call("libgtk-4.so.1", "gdk_content_deserializer_get_value", [
@@ -87,8 +85,6 @@ export class ContentDeserializer extends GObject.GObject {
             innerType: "GValue",
             lib: "libgtk-4.so.1",
         });
-        if (ptr === null)
-            return null;
         return wrapPtr(ptr, GObject.Value);
     }
     returnError(error) {
@@ -118,12 +114,12 @@ export class ContentDeserializer extends GObject.GObject {
                 value: this.ptr,
             },
             {
-                type: { type: "gobject" },
-                value: data?.ptr ?? data,
+                type: { type: "int", size: 64, unsigned: true },
+                value: data,
             },
             {
-                type: { type: "gobject" },
-                value: notify?.ptr ?? notify,
+                type: { type: "callback", trampoline: "destroy" },
+                value: notify,
             },
         ], { type: "undefined" });
     }