@gtkx/ffi 0.1.1 → 0.1.2

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

@@ -16,13 +16,13 @@ export declare class CodeGenerator {
     generateNamespace(namespace: GirNamespace): Promise<Map<string, string>>;
     private registerEnumsAndBitfields;
     private buildClassMap;
-    private buildParentClassSet;
     private attachConstructorFunctions;
     private getStandaloneFunctions;
     private resetState;
     private generateClass;
     private generateConstructors;
     private generateConstructor;
+    private generateCreatePtr;
     private generateStaticFactoryMethod;
     private generateMethods;
     private generateMethod;

package/dist/codegen/ffi-generator.js

@@ -69,10 +69,26 @@ const METHOD_RENAMES = new Map([
 ]);
 const toKebabCase = (str) => str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
 const toConstantCase = (str) => str.replace(/-/g, "_").toUpperCase();
+const sanitizeDoc = (doc) => {
+    let result = doc;
+    result = result.replace(/<picture>[\s\S]*?<\/picture>/gi, "");
+    result = result.replace(/<img[^>]*>/gi, "");
+    result = result.replace(/<source[^>]*>/gi, "");
+    result = result.replace(/!\[[^\]]*\]\([^)]+\.png\)/gi, "");
+    result = result.replace(/<kbd>([^<]*)<\/kbd>/gi, "`$1`");
+    result = result.replace(/<kbd>/gi, "`");
+    result = result.replace(/<\/kbd>/gi, "`");
+    result = result.replace(/\[([^\]]+)\]\([^)]+\.html[^)]*\)/gi, "$1");
+    result = result.replace(/@(\w+)\s/g, "`$1` ");
+    return result.trim();
+};
 const formatDoc = (doc, indent = "") => {
     if (!doc)
         return "";
-    const lines = doc.split("\n").map((line) => line.trim());
+    const sanitized = sanitizeDoc(doc);
+    if (!sanitized)
+        return "";
+    const lines = sanitized.split("\n").map((line) => line.trim());
     const firstLine = lines[0] ?? "";
     if (lines.length === 1 && firstLine.length < 80) {
         return `${indent}/** ${firstLine} */\n`;
@@ -81,18 +97,20 @@ const formatDoc = (doc, indent = "") => {
     return `${indent}/**\n${formattedLines.join("\n")}\n${indent} */\n`;
 };
 const formatMethodDoc = (doc, params, indent = "  ") => {
-    if (!doc && params.every((p) => !p.doc))
+    const sanitizedDoc = doc ? sanitizeDoc(doc) : undefined;
+    if (!sanitizedDoc && params.every((p) => !p.doc))
         return "";
     const lines = [];
-    if (doc) {
-        for (const line of doc.split("\n")) {
+    if (sanitizedDoc) {
+        for (const line of sanitizedDoc.split("\n")) {
             lines.push(` * ${line.trim()}`);
         }
     }
     for (const param of params) {
         if (param.doc && param.name && param.name !== "..." && param.name !== "") {
             const paramName = toValidIdentifier(toCamelCase(param.name));
-            const paramDoc = param.doc.split("\n")[0]?.trim() ?? "";
+            const sanitizedParamDoc = sanitizeDoc(param.doc);
+            const paramDoc = sanitizedParamDoc.split("\n")[0]?.trim() ?? "";
             lines.push(` * @param ${paramName} - ${paramDoc}`);
         }
     }
@@ -128,12 +146,11 @@ export class CodeGenerator {
         this.registerEnumsAndBitfields(namespace);
         const classMap = this.buildClassMap(namespace);
         this.attachConstructorFunctions(namespace, classMap);
-        const parentClasses = this.buildParentClassSet(classMap);
         for (const iface of namespace.interfaces) {
             files.set(`${toKebabCase(iface.name)}.ts`, await this.generateInterface(iface, namespace.sharedLibrary, classMap));
         }
         for (const cls of namespace.classes) {
-            files.set(`${toKebabCase(cls.name)}.ts`, await this.generateClass(cls, namespace.sharedLibrary, classMap, parentClasses));
+            files.set(`${toKebabCase(cls.name)}.ts`, await this.generateClass(cls, namespace.sharedLibrary, classMap));
         }
         const standaloneFunctions = this.getStandaloneFunctions(namespace, classMap);
         if (standaloneFunctions.length > 0) {
@@ -161,15 +178,6 @@ export class CodeGenerator {
         }
         return classMap;
     }
-    buildParentClassSet(classMap) {
-        const parentClasses = new Set();
-        for (const cls of classMap.values()) {
-            if (cls.parent && classMap.has(cls.parent)) {
-                parentClasses.add(cls.parent);
-            }
-        }
-        return parentClasses;
-    }
     attachConstructorFunctions(namespace, classMap) {
         for (const func of namespace.functions) {
             const match = func.cIdentifier?.match(/^[a-z_]+_([a-z_]+)_new(_.*)?$/);
@@ -210,7 +218,7 @@ export class CodeGenerator {
         this.signalClasses.clear();
         this.typeMapper.setEnumUsageCallback((enumName) => this.usedEnums.add(enumName));
     }
-    async generateClass(cls, sharedLibrary, classMap, parentClasses) {
+    async generateClass(cls, sharedLibrary, classMap) {
         this.resetState();
         this.usesRef =
             cls.methods.some((m) => hasOutParameter(m.parameters)) ||
@@ -220,7 +228,6 @@ export class CodeGenerator {
         const hasParent = !!(cls.parent && classMap.has(cls.parent));
         const parentClassName = cls.parent ? normalizeClassName(cls.parent) : "";
         const extendsClause = hasParent ? ` extends ${parentClassName}` : "";
-        const isParentClass = parentClasses.has(cls.name);
         const sections = [];
         if (hasParent && cls.parent) {
             sections.push(`import { ${parentClassName} } from "./${toKebabCase(cls.parent)}.js";`);
@@ -233,10 +240,8 @@ export class CodeGenerator {
         if (!extendsClause) {
             sections.push(`  ptr: unknown;\n`);
         }
-        else if (cls.constructors.length === 0) {
-            sections.push(`  ptr: unknown = undefined as any;\n`);
-        }
-        sections.push(this.generateConstructors(cls, sharedLibrary, hasParent, isParentClass));
+        sections.push(this.generateConstructors(cls, sharedLibrary, hasParent));
+        sections.push(this.generateCreatePtr(cls, sharedLibrary, hasParent));
         sections.push(this.generateMethods(cls.methods, sharedLibrary, cls.name));
         sections.push(this.generateProperties(cls.properties, cls.methods));
         if (cls.signals.length > 0) {
@@ -247,64 +252,86 @@ export class CodeGenerator {
         const imports = this.generateImports(className, hasParent ? parentClassName : undefined);
         return this.formatCode(imports + sections.join("\n"));
     }
-    generateConstructors(cls, sharedLibrary, hasParent, isParentClass) {
-        if (cls.constructors.length === 0) {
-            if (isParentClass && hasParent) {
-                return `  constructor(_skipCreate?: boolean) {\n    super(true);\n  }\n`;
-            }
-            if (isParentClass) {
-                return `  constructor(_skipCreate?: boolean) {}\n`;
-            }
-            if (hasParent) {
-                return `  constructor() {\n    super(true);\n  }\n`;
-            }
-            return "";
-        }
+    generateConstructors(cls, _sharedLibrary, hasParent) {
         const mainConstructor = cls.constructors.find((c) => !c.parameters.some(isVararg));
         const sections = [];
         if (mainConstructor) {
-            sections.push(this.generateConstructor(mainConstructor, cls.name, sharedLibrary, hasParent, isParentClass));
+            sections.push(this.generateConstructor(mainConstructor, hasParent));
             for (const ctor of cls.constructors) {
                 if (ctor !== mainConstructor) {
-                    sections.push(this.generateStaticFactoryMethod(ctor, cls.name, sharedLibrary));
+                    sections.push(this.generateStaticFactoryMethod(ctor, cls.name, _sharedLibrary));
                 }
             }
         }
-        else {
+        else if (cls.constructors.length > 0) {
             for (const ctor of cls.constructors) {
-                sections.push(this.generateStaticFactoryMethod(ctor, cls.name, sharedLibrary));
+                sections.push(this.generateStaticFactoryMethod(ctor, cls.name, _sharedLibrary));
+            }
+        }
+        if (!mainConstructor) {
+            if (hasParent) {
+                sections.push(`  constructor(_args: unknown[] = []) {\n    super(_args);\n  }\n`);
+            }
+            else {
+                sections.push(`  constructor(_args: unknown[] = []) {\n    this.ptr = this.createPtr(_args);\n  }\n`);
             }
         }
         return sections.join("\n");
     }
-    generateConstructor(ctor, _className, sharedLibrary, hasParent, isParentClass) {
-        const args = this.generateCallArguments(ctor.parameters);
+    generateConstructor(ctor, hasParent) {
         const ctorDoc = formatMethodDoc(ctor.doc, ctor.parameters);
-        if (isParentClass) {
-            const params = this.generateParameterList(ctor.parameters, true);
-            const allParams = params ? `_skipCreate?: boolean, ${params}` : "_skipCreate?: boolean";
-            return `${ctorDoc}  constructor(${allParams}) {
-${hasParent ? "    super(true);\n" : ""}    if (!_skipCreate) this.ptr = call(
-      "${sharedLibrary}",
-      "${ctor.cIdentifier}",
-      [
-${args}
-      ],
-      { type: "gobject", borrowed: true }
-    ) as unknown;
+        const filteredParams = ctor.parameters.filter((p) => !isVararg(p));
+        if (filteredParams.length === 0) {
+            if (hasParent) {
+                return `${ctorDoc}  constructor(_args: unknown[] = []) {\n    super(_args);\n  }\n`;
+            }
+            return `${ctorDoc}  constructor(_args: unknown[] = []) {\n    this.ptr = this.createPtr(_args);\n  }\n`;
+        }
+        const typedParams = this.generateParameterList(ctor.parameters, false);
+        const paramNames = filteredParams.map((p) => toValidIdentifier(toCamelCase(p.name)));
+        const firstParamType = this.typeMapper.mapParameter(filteredParams[0]).ts;
+        const isFirstParamArray = firstParamType.endsWith("[]") || firstParamType.startsWith("Array<");
+        const superOrCreate = hasParent ? "super(_args)" : "this.ptr = this.createPtr(_args)";
+        if (isFirstParamArray) {
+            return `${ctorDoc}  constructor(${typedParams}) {
+    const _args = [${paramNames.join(", ")}];
+    ${superOrCreate};
   }
 `;
         }
-        const params = this.generateParameterList(ctor.parameters, true);
-        return `${ctorDoc}  constructor(${params}) {
-${hasParent ? "    super(true);\n" : ""}    this.ptr = call(
+        return `${ctorDoc}  constructor(${typedParams});
+  constructor(_args: unknown[]);
+  constructor(...args: unknown[]) {
+    const _args = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+    ${superOrCreate};
+  }
+`;
+    }
+    generateCreatePtr(cls, sharedLibrary, hasParent) {
+        const mainConstructor = cls.constructors.find((c) => !c.parameters.some(isVararg));
+        if (!mainConstructor) {
+            if (hasParent) {
+                return `  protected override createPtr(_args: unknown[]): unknown {\n    return null;\n  }\n`;
+            }
+            return `  protected createPtr(_args: unknown[]): unknown {\n    return null;\n  }\n`;
+        }
+        const filteredParams = mainConstructor.parameters.filter((p) => !isVararg(p));
+        const paramTypes = filteredParams.map((p) => this.typeMapper.mapParameter(p).ts);
+        const paramNames = filteredParams.map((p) => toValidIdentifier(toCamelCase(p.name)));
+        const destructuring = paramNames.length > 0
+            ? `    const [${paramNames.join(", ")}] = _args as [${paramTypes.join(", ")}];\n`
+            : "";
+        const args = this.generateCallArguments(mainConstructor.parameters);
+        const override = hasParent ? "override " : "";
+        return `  protected ${override}createPtr(_args: unknown[]): unknown {
+${destructuring}    return call(
       "${sharedLibrary}",
-      "${ctor.cIdentifier}",
+      "${mainConstructor.cIdentifier}",
       [
 ${args}
       ],
       { type: "gobject", borrowed: true }
-    ) as unknown;
+    );
   }
 `;
     }
@@ -475,23 +502,23 @@ ${allArgs ? `${allArgs},` : ""}
             return `    "${signal.name}": [${paramEntries.join(", ")}]`;
         });
         this.typeMapper.setEnumUsageCallback(savedCallback);
-        if (signalMetadata.length > 0) {
-            this.usesType = true;
-        }
+        this.usesType = true;
         const signalMapCode = signalMetadata.length > 0
             ? `const signalMeta: Record<string, { type: Type; cls?: { prototype: object } }[]> = {\n${signalMetadata.join(",\n")}\n  };
     const meta = signalMeta[signal];
-    const argTypes = meta?.map((m) => m.type);`
-            : `const meta = undefined;\n    const argTypes = undefined;`;
+    const selfType: Type = { type: "gobject", borrowed: false };
+    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 wrapperCode = `const wrappedHandler = (...args: unknown[]) => {
-      if (!meta) return handler(...args);
+      const signalArgs = args.slice(1);
+      if (!meta) return handler(...signalArgs);
       const wrapped = meta.map((m, i) => {
-        if (m.cls && args[i] != null) {
+        if (m.cls && signalArgs[i] != null) {
           const inst = Object.create(m.cls.prototype) as { ptr: unknown };
-          inst.ptr = args[i];
+          inst.ptr = signalArgs[i];
           return inst;
         }
-        return args[i];
+        return signalArgs[i];
       });
       return handler(...wrapped);
     };`;

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

@@ -1,5 +1,7 @@
 export declare class AppLaunchContext {
     ptr: unknown;
+    constructor(_args?: unknown[]);
+    protected createPtr(_args: unknown[]): unknown;
     getDisplay(): unknown;
     setDesktop(desktop: number): void;
     setIcon(icon?: unknown): void;

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

@@ -1,6 +1,12 @@
 import { call } from "@gtkx/native";
 export class AppLaunchContext {
     ptr;
+    constructor(_args = []) {
+        this.ptr = this.createPtr(_args);
+    }
+    createPtr(_args) {
+        return null;
+    }
     getDisplay() {
         return call("libgtk-4.so.1", "gdk_app_launch_context_get_display", [
             {

package/dist/generated/gdk/button-event.d.ts

@@ -1,6 +1,6 @@
 import { Event } from "./event.js";
 export declare class ButtonEvent extends Event {
-    ptr: unknown;
-    constructor();
+    constructor(_args?: unknown[]);
+    protected createPtr(_args: unknown[]): unknown;
     getButton(): number;
 }

package/dist/generated/gdk/button-event.js

@@ -1,9 +1,11 @@
 import { call } from "@gtkx/native";
 import { Event } from "./event.js";
 export class ButtonEvent extends Event {
-    ptr = undefined;
-    constructor() {
-        super(true);
+    constructor(_args = []) {
+        super(_args);
+    }
+    createPtr(_args) {
+        return null;
     }
     getButton() {
         return call("libgtk-4.so.1", "gdk_button_event_get_button", [

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

@@ -1,6 +1,6 @@
 import { DrawContext } from "./draw-context.js";
 export declare class CairoContext extends DrawContext {
-    ptr: unknown;
-    constructor();
+    constructor(_args?: unknown[]);
+    protected createPtr(_args: unknown[]): unknown;
     cairoCreate(): unknown;
 }

package/dist/generated/gdk/cairo-context.js

@@ -1,9 +1,11 @@
 import { call } from "@gtkx/native";
 import { DrawContext } from "./draw-context.js";
 export class CairoContext extends DrawContext {
-    ptr = undefined;
-    constructor() {
-        super(true);
+    constructor(_args = []) {
+        super(_args);
+    }
+    createPtr(_args) {
+        return null;
     }
     cairoCreate() {
         return call("libgtk-4.so.1", "gdk_cairo_context_cairo_create", [

package/dist/generated/gdk/cicp-params.d.ts

@@ -1,7 +1,8 @@
 import { CicpRange } from "./enums.js";
 export declare class CicpParams {
     ptr: unknown;
-    constructor();
+    constructor(_args?: unknown[]);
+    protected createPtr(_args: unknown[]): unknown;
     buildColorState(): unknown;
     getColorPrimaries(): number;
     getMatrixCoefficients(): number;

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

@@ -1,8 +1,11 @@
 import { call } from "@gtkx/native";
 export class CicpParams {
     ptr;
-    constructor() {
-        this.ptr = call("libgtk-4.so.1", "gdk_cicp_params_new", [], {
+    constructor(_args = []) {
+        this.ptr = this.createPtr(_args);
+    }
+    createPtr(_args) {
+        return call("libgtk-4.so.1", "gdk_cicp_params_new", [], {
             type: "gobject",
             borrowed: true,
         });

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

@@ -1,6 +1,8 @@
 import { Ref } from "@gtkx/native";
 export declare class Clipboard {
     ptr: unknown;
+    constructor(_args?: unknown[]);
+    protected createPtr(_args: unknown[]): unknown;
     getContent(): unknown;
     getDisplay(): unknown;
     getFormats(): unknown;

package/dist/generated/gdk/clipboard.js

@@ -1,6 +1,12 @@
 import { call } from "@gtkx/native";
 export class Clipboard {
     ptr;
+    constructor(_args = []) {
+        this.ptr = this.createPtr(_args);
+    }
+    createPtr(_args) {
+        return null;
+    }
     getContent() {
         return call("libgtk-4.so.1", "gdk_clipboard_get_content", [
             {
@@ -365,17 +371,19 @@ export class Clipboard {
             changed: [],
         };
         const meta = signalMeta[signal];
-        const argTypes = meta?.map((m) => m.type);
+        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(...args);
+                return handler(...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && args[i] != null) {
+                if (m.cls && signalArgs[i] != null) {
                     const inst = Object.create(m.cls.prototype);
-                    inst.ptr = args[i];
+                    inst.ptr = signalArgs[i];
                     return inst;
                 }
-                return args[i];
+                return signalArgs[i];
             });
             return handler(...wrapped);
         };

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

@@ -1,5 +1,7 @@
 export declare class ContentDeserializer {
     ptr: unknown;
+    constructor(_args?: unknown[]);
+    protected createPtr(_args: unknown[]): unknown;
     getCancellable(): unknown;
     getGtype(): number;
     getInputStream(): unknown;

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

@@ -1,6 +1,12 @@
 import { call } from "@gtkx/native";
 export class ContentDeserializer {
     ptr;
+    constructor(_args = []) {
+        this.ptr = this.createPtr(_args);
+    }
+    createPtr(_args) {
+        return null;
+    }
     getCancellable() {
         return call("libgtk-4.so.1", "gdk_content_deserializer_get_cancellable", [
             {

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

@@ -1,10 +1,12 @@
 import { Ref } from "@gtkx/native";
 export declare class ContentProvider {
     ptr: unknown;
-    constructor(mimeType?: string, bytes?: unknown);
+    constructor(mimeType: string, bytes: unknown);
+    constructor(_args: unknown[]);
     static providerNewForValue(value: unknown): ContentProvider;
     static providerNewTyped(type: number): ContentProvider;
     static providerNewUnion(nProviders: unknown, providers?: unknown[]): ContentProvider;
+    protected createPtr(_args: unknown[]): unknown;
     contentChanged(): void;
     getValue(value: Ref<unknown>): boolean;
     refFormats(): unknown;

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

@@ -1,17 +1,9 @@
 import { call } from "@gtkx/native";
 export class ContentProvider {
     ptr;
-    constructor(mimeType, bytes) {
-        this.ptr = call("libgtk-4.so.1", "gdk_content_provider_new_for_bytes", [
-            {
-                type: { type: "string" },
-                value: mimeType,
-            },
-            {
-                type: { type: "gobject" },
-                value: bytes,
-            },
-        ], { type: "gobject", borrowed: true });
+    constructor(...args) {
+        const _args = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+        this.ptr = this.createPtr(_args);
     }
     static providerNewForValue(value) {
         const ptr = call("libgtk-4.so.1", "gdk_content_provider_new_for_value", [
@@ -50,6 +42,19 @@ export class ContentProvider {
         instance.ptr = ptr;
         return instance;
     }
+    createPtr(_args) {
+        const [mimeType, bytes] = _args;
+        return call("libgtk-4.so.1", "gdk_content_provider_new_for_bytes", [
+            {
+                type: { type: "string" },
+                value: mimeType,
+            },
+            {
+                type: { type: "gobject" },
+                value: bytes,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
     contentChanged() {
         call("libgtk-4.so.1", "gdk_content_provider_content_changed", [
             {
@@ -163,17 +168,19 @@ export class ContentProvider {
             "content-changed": [],
         };
         const meta = signalMeta[signal];
-        const argTypes = meta?.map((m) => m.type);
+        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(...args);
+                return handler(...signalArgs);
             const wrapped = meta.map((m, i) => {
-                if (m.cls && args[i] != null) {
+                if (m.cls && signalArgs[i] != null) {
                     const inst = Object.create(m.cls.prototype);
-                    inst.ptr = args[i];
+                    inst.ptr = signalArgs[i];
                     return inst;
                 }
-                return args[i];
+                return signalArgs[i];
             });
             return handler(...wrapped);
         };

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

@@ -1,5 +1,7 @@
 export declare class ContentSerializer {
     ptr: unknown;
+    constructor(_args?: unknown[]);
+    protected createPtr(_args: unknown[]): unknown;
     getCancellable(): unknown;
     getGtype(): number;
     getMimeType(): string;

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

@@ -1,6 +1,12 @@
 import { call } from "@gtkx/native";
 export class ContentSerializer {
     ptr;
+    constructor(_args = []) {
+        this.ptr = this.createPtr(_args);
+    }
+    createPtr(_args) {
+        return null;
+    }
     getCancellable() {
         return call("libgtk-4.so.1", "gdk_content_serializer_get_cancellable", [
             {

package/dist/generated/gdk/crossing-event.d.ts

@@ -1,8 +1,8 @@
 import { CrossingMode, NotifyType } from "./enums.js";
 import { Event } from "./event.js";
 export declare class CrossingEvent extends Event {
-    ptr: unknown;
-    constructor();
+    constructor(_args?: unknown[]);
+    protected createPtr(_args: unknown[]): unknown;
     getDetail(): NotifyType;
     getFocus(): boolean;
     getMode(): CrossingMode;

package/dist/generated/gdk/crossing-event.js

@@ -1,9 +1,11 @@
 import { call } from "@gtkx/native";
 import { Event } from "./event.js";
 export class CrossingEvent extends Event {
-    ptr = undefined;
-    constructor() {
-        super(true);
+    constructor(_args = []) {
+        super(_args);
+    }
+    createPtr(_args) {
+        return null;
     }
     getDetail() {
         return call("libgtk-4.so.1", "gdk_crossing_event_get_detail", [

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

@@ -1,8 +1,10 @@
 export declare class Cursor {
     ptr: unknown;
-    constructor(callback?: unknown, data?: unknown, destroy?: unknown, fallback?: unknown);
+    constructor(callback: unknown, destroy: unknown, data?: unknown, fallback?: unknown);
+    constructor(_args: unknown[]);
     static newFromName(name: string, fallback?: unknown): Cursor;
     static newFromTexture(texture: unknown, hotspotX: number, hotspotY: number, fallback?: unknown): Cursor;
+    protected createPtr(_args: unknown[]): unknown;
     getFallback(): unknown;
     getHotspotX(): number;
     getHotspotY(): number;

package/dist/generated/gdk/cursor.js

@@ -1,25 +1,9 @@
 import { call } from "@gtkx/native";
 export class Cursor {
     ptr;
-    constructor(callback, data, destroy, fallback) {
-        this.ptr = call("libgtk-4.so.1", "gdk_cursor_new_from_callback", [
-            {
-                type: { type: "gobject" },
-                value: callback,
-            },
-            {
-                type: { type: "gobject" },
-                value: data,
-            },
-            {
-                type: { type: "gobject" },
-                value: destroy,
-            },
-            {
-                type: { type: "gobject" },
-                value: fallback,
-            },
-        ], { type: "gobject", borrowed: true });
+    constructor(...args) {
+        const _args = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+        this.ptr = this.createPtr(_args);
     }
     static newFromName(name, fallback) {
         const ptr = call("libgtk-4.so.1", "gdk_cursor_new_from_name", [
@@ -59,6 +43,27 @@ export class Cursor {
         instance.ptr = ptr;
         return instance;
     }
+    createPtr(_args) {
+        const [callback, data, destroy, fallback] = _args;
+        return call("libgtk-4.so.1", "gdk_cursor_new_from_callback", [
+            {
+                type: { type: "gobject" },
+                value: callback,
+            },
+            {
+                type: { type: "gobject" },
+                value: data,
+            },
+            {
+                type: { type: "gobject" },
+                value: destroy,
+            },
+            {
+                type: { type: "gobject" },
+                value: fallback,
+            },
+        ], { type: "gobject", borrowed: true });
+    }
     getFallback() {
         return call("libgtk-4.so.1", "gdk_cursor_get_fallback", [
             {