@gtkx/ffi 0.1.4 → 0.1.6

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

@@ -10,11 +10,20 @@ export declare class CodeGenerator {
     private usesRef;
     private usesCall;
     private usesType;
+    private usesRead;
+    private usesWrite;
+    private usesAlloc;
+    private usesNativeError;
     private usedEnums;
+    private usedRecords;
     private signalClasses;
+    private recordNameToFile;
+    private currentSharedLibrary;
     constructor(options: GeneratorOptions);
     generateNamespace(namespace: GirNamespace): Promise<Map<string, string>>;
     private registerEnumsAndBitfields;
+    private registerRecords;
+    private shouldGenerateRecord;
     private buildClassMap;
     private attachConstructorFunctions;
     private getStandaloneFunctions;
@@ -33,6 +42,21 @@ export declare class CodeGenerator {
     private extractSignalParamClass;
     private generateSignalConnect;
     private generateInterface;
+    private generateRecord;
+    private generateRecordInitInterface;
+    private generateRecordConstructors;
+    private getWritableFields;
+    private generateFieldInitInterface;
+    private generateRecordCreatePtr;
+    private generateFieldWrites;
+    private calculateStructSize;
+    private generateRecordStaticFactoryMethod;
+    private generateRecordStaticFunctions;
+    private generateRecordMethods;
+    private generateRecordFields;
+    private isWritableType;
+    private getFieldSize;
+    private getFieldAlignment;
     private generateFunctions;
     private generateFunction;
     private generateEnums;

package/dist/codegen/ffi-generator.js

@@ -48,6 +48,8 @@ const RESERVED_WORDS = new Set([
     "public",
     "await",
     "async",
+    "eval",
+    "arguments",
 ]);
 const METHOD_RENAMES = new Map([
     ["IconView", new Map([["setCursor", "setCursorPath"]])],
@@ -67,7 +69,13 @@ const METHOD_RENAMES = new Map([
         ]),
     ],
 ]);
-const toKebabCase = (str) => str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+const CLASS_RENAMES = new Map([
+    ["Error", "GError"],
+]);
+const toKebabCase = (str) => str
+    .replace(/([a-z])([A-Z])/g, "$1-$2")
+    .replace(/_/g, "-")
+    .toLowerCase();
 const toConstantCase = (str) => str.replace(/-/g, "_").toUpperCase();
 const sanitizeDoc = (doc) => {
     let result = doc;
@@ -126,7 +134,16 @@ const toValidIdentifier = (str) => {
         result = `_${result}`;
     return result;
 };
-const normalizeClassName = (name) => (name === "Object" ? "GObject" : toPascalCase(name));
+const normalizeClassName = (name) => {
+    const pascalName = toPascalCase(name);
+    if (CLASS_RENAMES.has(pascalName)) {
+        return CLASS_RENAMES.get(pascalName);
+    }
+    if (pascalName === "Object") {
+        return "GObject";
+    }
+    return pascalName;
+};
 const hasOutParameter = (params) => params.some((p) => p.direction === "out" || p.direction === "inout");
 const isVararg = (param) => param.name === "..." || param.name === "";
 export class CodeGenerator {
@@ -135,15 +152,24 @@ export class CodeGenerator {
     usesRef = false;
     usesCall = false;
     usesType = false;
+    usesRead = false;
+    usesWrite = false;
+    usesAlloc = false;
+    usesNativeError = false;
     usedEnums = new Set();
+    usedRecords = new Set();
     signalClasses = new Set();
+    recordNameToFile = new Map();
+    currentSharedLibrary = "";
     constructor(options) {
         this.options = options;
         this.typeMapper = new TypeMapper();
     }
     async generateNamespace(namespace) {
         const files = new Map();
+        this.currentSharedLibrary = namespace.sharedLibrary;
         this.registerEnumsAndBitfields(namespace);
+        this.registerRecords(namespace);
         const classMap = this.buildClassMap(namespace);
         this.attachConstructorFunctions(namespace, classMap);
         for (const iface of namespace.interfaces) {
@@ -152,6 +178,11 @@ export class CodeGenerator {
         for (const cls of namespace.classes) {
             files.set(`${toKebabCase(cls.name)}.ts`, await this.generateClass(cls, namespace.sharedLibrary, classMap));
         }
+        for (const record of namespace.records) {
+            if (this.shouldGenerateRecord(record)) {
+                files.set(`${toKebabCase(record.name)}.ts`, await this.generateRecord(record, namespace.sharedLibrary));
+            }
+        }
         const standaloneFunctions = this.getStandaloneFunctions(namespace, classMap);
         if (standaloneFunctions.length > 0) {
             files.set("functions.ts", await this.generateFunctions(standaloneFunctions, namespace.sharedLibrary));
@@ -171,6 +202,28 @@ export class CodeGenerator {
             this.typeMapper.registerEnum(bitfield.name, toPascalCase(bitfield.name));
         }
     }
+    registerRecords(namespace) {
+        for (const record of namespace.records) {
+            if (this.shouldGenerateRecord(record)) {
+                const normalizedName = normalizeClassName(record.name);
+                this.typeMapper.registerRecord(record.name, normalizedName, record.glibTypeName);
+                this.recordNameToFile.set(normalizedName, record.name);
+            }
+        }
+    }
+    shouldGenerateRecord(record) {
+        if (record.disguised)
+            return false;
+        if (record.name.endsWith("Class"))
+            return false;
+        if (record.name.endsWith("Private"))
+            return false;
+        if (record.name.endsWith("Iface"))
+            return false;
+        if (!record.glibTypeName)
+            return false;
+        return true;
+    }
     buildClassMap(namespace) {
         const classMap = new Map();
         for (const cls of namespace.classes) {
@@ -214,9 +267,15 @@ export class CodeGenerator {
         this.usesRef = false;
         this.usesCall = false;
         this.usesType = false;
+        this.usesRead = false;
+        this.usesWrite = false;
+        this.usesAlloc = false;
+        this.usesNativeError = false;
         this.usedEnums.clear();
+        this.usedRecords.clear();
         this.signalClasses.clear();
         this.typeMapper.setEnumUsageCallback((enumName) => this.usedEnums.add(enumName));
+        this.typeMapper.setRecordUsageCallback((recordName) => this.usedRecords.add(recordName));
     }
     async generateClass(cls, sharedLibrary, classMap) {
         this.resetState();
@@ -561,8 +620,10 @@ ${allArgs ? `${allArgs},` : ""}
     }
     generateSignalConnect(sharedLibrary, signals, hasConnectMethod, classMap) {
         const methodName = hasConnectMethod ? "on" : "connect";
-        const savedCallback = this.typeMapper.getEnumUsageCallback();
+        const savedEnumCallback = this.typeMapper.getEnumUsageCallback();
+        const savedRecordCallback = this.typeMapper.getRecordUsageCallback();
         this.typeMapper.setEnumUsageCallback(null);
+        this.typeMapper.setRecordUsageCallback(null);
         const signalMetadata = signals.map((signal) => {
             const paramEntries = (signal.parameters ?? []).map((param) => {
                 const ffiType = JSON.stringify(this.typeMapper.mapType(param.type).ffi);
@@ -575,7 +636,8 @@ ${allArgs ? `${allArgs},` : ""}
             });
             return `    "${signal.name}": [${paramEntries.join(", ")}]`;
         });
-        this.typeMapper.setEnumUsageCallback(savedCallback);
+        this.typeMapper.setEnumUsageCallback(savedEnumCallback);
+        this.typeMapper.setRecordUsageCallback(savedRecordCallback);
         this.usesType = true;
         const signalMapCode = signalMetadata.length > 0
             ? `const signalMeta: Record<string, { type: Type; cls?: { prototype: object } }[]> = {\n${signalMetadata.join(",\n")}\n  };
@@ -638,6 +700,297 @@ ${allArgs ? `${allArgs},` : ""}
         const imports = this.generateImports(interfaceName);
         return this.formatCode(imports + sections.join("\n"));
     }
+    async generateRecord(record, sharedLibrary) {
+        this.resetState();
+        this.usesRef =
+            record.methods.some((m) => hasOutParameter(m.parameters)) ||
+                record.constructors.some((c) => hasOutParameter(c.parameters)) ||
+                record.functions.some((f) => hasOutParameter(f.parameters));
+        this.usesCall =
+            record.methods.length > 0 || record.constructors.length > 0 || record.functions.length > 0;
+        const hasReadableFields = record.fields.some((f) => f.readable !== false && !f.private);
+        if (hasReadableFields) {
+            this.usesRead = true;
+        }
+        const recordName = normalizeClassName(record.name);
+        const sections = [];
+        const initInterface = this.generateRecordInitInterface(record);
+        if (initInterface) {
+            sections.push(initInterface);
+        }
+        if (record.doc) {
+            sections.push(formatDoc(record.doc));
+        }
+        sections.push(`export class ${recordName} {`);
+        sections.push(`  ptr: unknown;\n`);
+        sections.push(this.generateRecordConstructors(record, sharedLibrary));
+        sections.push(this.generateRecordStaticFunctions(record.functions, sharedLibrary, recordName));
+        sections.push(this.generateRecordMethods(record.methods, sharedLibrary, record.name));
+        sections.push(this.generateRecordFields(record.fields, record.methods));
+        sections.push("}");
+        const imports = this.generateImports(recordName);
+        return this.formatCode(imports + sections.join("\n"));
+    }
+    generateRecordInitInterface(record) {
+        const mainConstructor = record.constructors.find((c) => !c.parameters.some(isVararg));
+        if (mainConstructor)
+            return null;
+        const initFields = this.getWritableFields(record.fields);
+        if (initFields.length === 0)
+            return null;
+        const recordName = normalizeClassName(record.name);
+        return this.generateFieldInitInterface(recordName, initFields);
+    }
+    generateRecordConstructors(record, sharedLibrary) {
+        const recordName = normalizeClassName(record.name);
+        const sections = [];
+        const mainConstructor = record.constructors.find((c) => !c.parameters.some(isVararg));
+        if (mainConstructor) {
+            const ctorDoc = formatMethodDoc(mainConstructor.doc, mainConstructor.parameters);
+            const filteredParams = mainConstructor.parameters.filter((p) => !isVararg(p));
+            if (filteredParams.length === 0) {
+                sections.push(`${ctorDoc}  constructor() {\n    this.ptr = this.createPtr([]);\n  }\n`);
+            }
+            else {
+                const typedParams = this.generateParameterList(mainConstructor.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<");
+                if (isFirstParamArray) {
+                    sections.push(`${ctorDoc}  constructor(${typedParams}) {
+    const _args = [${paramNames.join(", ")}];
+    this.ptr = this.createPtr(_args);
+  }
+`);
+                }
+                else {
+                    sections.push(`${ctorDoc}  constructor(${typedParams});
+  constructor(_args: unknown[]);
+  constructor(...args: unknown[]) {
+    const _args = args.length === 1 && Array.isArray(args[0]) ? args[0] : args;
+    this.ptr = this.createPtr(_args);
+  }
+`);
+                }
+            }
+            for (const ctor of record.constructors) {
+                if (ctor !== mainConstructor) {
+                    sections.push(this.generateRecordStaticFactoryMethod(ctor, recordName, sharedLibrary));
+                }
+            }
+        }
+        else {
+            const initFields = this.getWritableFields(record.fields);
+            if (initFields.length > 0) {
+                sections.push(`  constructor(init: ${recordName}Init = {}) {\n    this.ptr = this.createPtr(init);\n  }\n`);
+            }
+            else {
+                sections.push(`  constructor() {\n    this.ptr = this.createPtr({});\n  }\n`);
+            }
+        }
+        sections.push(this.generateRecordCreatePtr(record, sharedLibrary));
+        return sections.join("\n");
+    }
+    getWritableFields(fields) {
+        return fields.filter((f) => !f.private && f.writable !== false && this.isWritableType(f.type));
+    }
+    generateFieldInitInterface(recordName, fields) {
+        const properties = fields.map((field) => {
+            const fieldName = toValidIdentifier(toCamelCase(field.name));
+            const typeMapping = this.typeMapper.mapType(field.type);
+            return `  ${fieldName}?: ${typeMapping.ts};`;
+        });
+        return `export interface ${recordName}Init {\n${properties.join("\n")}\n}\n\n`;
+    }
+    generateRecordCreatePtr(record, sharedLibrary) {
+        const recordName = normalizeClassName(record.name);
+        const mainConstructor = record.constructors.find((c) => !c.parameters.some(isVararg));
+        if (!mainConstructor) {
+            if (record.glibTypeName && record.fields.length > 0) {
+                const structSize = this.calculateStructSize(record.fields);
+                const initFields = this.getWritableFields(record.fields);
+                this.usesAlloc = true;
+                if (initFields.length > 0) {
+                    const fieldWrites = this.generateFieldWrites(record.fields);
+                    this.usesWrite = true;
+                    return `  protected createPtr(init: ${recordName}Init): unknown {
+    const ptr = alloc(${structSize}, "${record.glibTypeName}", "${sharedLibrary}");
+${fieldWrites}
+    return ptr;
+  }
+`;
+                }
+                return `  protected createPtr(_init: Record<string, unknown>): unknown {
+    return alloc(${structSize}, "${record.glibTypeName}", "${sharedLibrary}");
+  }
+`;
+            }
+            return `  protected createPtr(_init: Record<string, 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 glibTypeName = record.glibTypeName ?? record.cType;
+        return `  protected createPtr(_args: unknown[]): unknown {
+${destructuring}    return call(
+      "${sharedLibrary}",
+      "${mainConstructor.cIdentifier}",
+      [
+${args}
+      ],
+      { type: "boxed", borrowed: true, innerType: "${glibTypeName}" }
+    );
+  }
+`;
+    }
+    generateFieldWrites(fields) {
+        const writes = [];
+        let currentOffset = 0;
+        for (const field of fields) {
+            if (field.private)
+                continue;
+            const fieldSize = this.getFieldSize(field.type);
+            const alignment = this.getFieldAlignment(field.type);
+            currentOffset = Math.ceil(currentOffset / alignment) * alignment;
+            if (field.writable !== false && this.isWritableType(field.type)) {
+                const fieldName = toValidIdentifier(toCamelCase(field.name));
+                const typeMapping = this.typeMapper.mapType(field.type);
+                writes.push(`    if (init.${fieldName} !== undefined) write(ptr, ${this.generateTypeDescriptor(typeMapping.ffi)}, ${currentOffset}, init.${fieldName});`);
+            }
+            currentOffset += fieldSize;
+        }
+        return writes.join("\n");
+    }
+    calculateStructSize(fields) {
+        let currentOffset = 0;
+        for (const field of fields) {
+            if (field.private)
+                continue;
+            const fieldSize = this.getFieldSize(field.type);
+            const alignment = this.getFieldAlignment(field.type);
+            currentOffset = Math.ceil(currentOffset / alignment) * alignment;
+            currentOffset += fieldSize;
+        }
+        const maxAlignment = Math.max(...fields.map((f) => this.getFieldAlignment(f.type)), 1);
+        return Math.ceil(currentOffset / maxAlignment) * maxAlignment;
+    }
+    generateRecordStaticFactoryMethod(ctor, recordName, sharedLibrary) {
+        let methodName = "new";
+        if (ctor.cIdentifier) {
+            const parts = ctor.cIdentifier.split("_");
+            const nameParts = parts.slice(2).join("_");
+            if (nameParts && nameParts !== "new") {
+                methodName = toCamelCase(nameParts);
+            }
+        }
+        const params = this.generateParameterList(ctor.parameters);
+        const args = this.generateCallArguments(ctor.parameters);
+        const ctorDoc = formatMethodDoc(ctor.doc, ctor.parameters);
+        return `${ctorDoc}  static ${methodName}(${params}): ${recordName} {
+    const ptr = call(
+      "${sharedLibrary}",
+      "${ctor.cIdentifier}",
+      [
+${args}
+      ],
+      { type: "boxed", borrowed: true, innerType: "${recordName}" }
+    );
+    const instance = Object.create(${recordName}.prototype) as ${recordName} & { ptr: unknown };
+    instance.ptr = ptr;
+    return instance;
+  }
+`;
+    }
+    generateRecordStaticFunctions(functions, sharedLibrary, recordName) {
+        return this.generateStaticFunctions(functions, sharedLibrary, recordName);
+    }
+    generateRecordMethods(methods, sharedLibrary, recordName) {
+        return this.generateMethods(methods, sharedLibrary, recordName);
+    }
+    generateRecordFields(fields, methods) {
+        const sections = [];
+        const fieldOffsets = [];
+        const methodNames = new Set(methods.map((m) => toCamelCase(m.name)));
+        let currentOffset = 0;
+        for (const field of fields) {
+            if (field.private)
+                continue;
+            const fieldSize = this.getFieldSize(field.type);
+            const alignment = this.getFieldAlignment(field.type);
+            currentOffset = Math.ceil(currentOffset / alignment) * alignment;
+            fieldOffsets.push({ field, offset: currentOffset });
+            currentOffset += fieldSize;
+        }
+        for (const { field, offset } of fieldOffsets) {
+            const isReadable = field.readable !== false;
+            const isWritable = field.writable !== false;
+            if (!isReadable && !isWritable)
+                continue;
+            const fieldName = toValidIdentifier(toCamelCase(field.name));
+            if (methodNames.has(fieldName))
+                continue;
+            const typeMapping = this.typeMapper.mapType(field.type);
+            if (field.doc) {
+                sections.push(formatDoc(field.doc, "  ").trimEnd());
+            }
+            if (isReadable) {
+                sections.push(`  get ${fieldName}(): ${typeMapping.ts} {
+    return read(this.ptr, ${this.generateTypeDescriptor(typeMapping.ffi)}, ${offset}) as ${typeMapping.ts};
+  }
+`);
+            }
+            if (isWritable && this.isWritableType(field.type)) {
+                this.usesWrite = true;
+                sections.push(`  set ${fieldName}(value: ${typeMapping.ts}) {
+    write(this.ptr, ${this.generateTypeDescriptor(typeMapping.ffi)}, ${offset}, value);
+  }
+`);
+            }
+        }
+        return sections.join("\n");
+    }
+    isWritableType(type) {
+        const typeName = type.name;
+        if (typeName === "gboolean" || typeName === "guint8" || typeName === "gint8" || typeName === "guchar" || typeName === "gchar") {
+            return true;
+        }
+        if (typeName === "gint16" || typeName === "guint16" || typeName === "gshort" || typeName === "gushort") {
+            return true;
+        }
+        if (typeName === "gint" || typeName === "guint" || typeName === "gint32" || typeName === "guint32") {
+            return true;
+        }
+        if (typeName === "gint64" || typeName === "guint64" || typeName === "glong" || typeName === "gulong" || typeName === "gsize" || typeName === "gssize") {
+            return true;
+        }
+        if (typeName === "gfloat" || typeName === "float" || typeName === "gdouble" || typeName === "double") {
+            return true;
+        }
+        return false;
+    }
+    getFieldSize(type) {
+        const typeName = type.name;
+        if (typeName === "gboolean" || typeName === "guint8" || typeName === "gint8" || typeName === "guchar" || typeName === "gchar") {
+            return 1;
+        }
+        if (typeName === "gint16" || typeName === "guint16" || typeName === "gshort" || typeName === "gushort") {
+            return 2;
+        }
+        if (typeName === "gint" || typeName === "guint" || typeName === "gint32" || typeName === "guint32" || typeName === "gfloat" || typeName === "float" || typeName === "Quark" || typeName === "GQuark") {
+            return 4;
+        }
+        if (typeName === "gint64" || typeName === "guint64" || typeName === "gdouble" || typeName === "double" || typeName === "glong" || typeName === "gulong" || typeName === "gsize" || typeName === "gssize" || typeName === "GType") {
+            return 8;
+        }
+        return 8;
+    }
+    getFieldAlignment(type) {
+        return this.getFieldSize(type);
+    }
     async generateFunctions(functions, sharedLibrary) {
         this.resetState();
         this.usesRef = functions.some((f) => hasOutParameter(f.parameters));
@@ -734,13 +1087,12 @@ ${allArgs ? `${allArgs},` : ""}
             .join(",\n");
     }
     generateErrorArgument(indent = "      ") {
-        return `${indent}  {\n${indent}    type: { type: "ref", innerType: { type: "gobject" } },\n${indent}    value: error,\n${indent}  }`;
+        return `${indent}  {\n${indent}    type: { type: "ref", innerType: { type: "boxed", innerType: "GError", lib: "libglib-2.0.so.0" } },\n${indent}    value: error,\n${indent}  }`;
     }
     generateErrorCheck(indent = "  ") {
+        this.usesNativeError = true;
         return `${indent}  if (error.value !== null) {
-${indent}    const jsError = new Error("GLib Error occurred");
-${indent}    (jsError as any).gError = error.value;
-${indent}    throw jsError;
+${indent}    throw new NativeError(error.value);
 ${indent}  }`;
     }
     generateTypeDescriptor(type) {
@@ -753,7 +1105,14 @@ ${indent}  }`;
         if (type.type === "gobject") {
             return type.borrowed ? `{ type: "gobject", borrowed: true }` : `{ type: "gobject" }`;
         }
-        if (type.type === "ref" && type.innerType) {
+        if (type.type === "boxed") {
+            const innerType = typeof type.innerType === "string" ? type.innerType : "";
+            const lib = this.currentSharedLibrary;
+            return type.borrowed
+                ? `{ type: "boxed", borrowed: true, innerType: "${innerType}", lib: "${lib}" }`
+                : `{ type: "boxed", innerType: "${innerType}", lib: "${lib}" }`;
+        }
+        if (type.type === "ref" && type.innerType && typeof type.innerType !== "string") {
             return `{ type: "ref", innerType: ${this.generateTypeDescriptor(type.innerType)} }`;
         }
         if (type.type === "array" && type.itemType) {
@@ -763,8 +1122,14 @@ ${indent}  }`;
     }
     generateImports(currentClassName, parentClassName) {
         const nativeImports = [];
+        if (this.usesAlloc)
+            nativeImports.push("alloc");
         if (this.usesCall)
             nativeImports.push("call");
+        if (this.usesRead)
+            nativeImports.push("read");
+        if (this.usesWrite)
+            nativeImports.push("write");
         if (this.usesRef)
             nativeImports.push("Ref");
         if (this.usesType)
@@ -773,10 +1138,21 @@ ${indent}  }`;
         if (nativeImports.length > 0) {
             lines.push(`import { ${nativeImports.join(", ")} } from "@gtkx/native";`);
         }
+        if (this.usesNativeError) {
+            lines.push(`import { NativeError } from "@gtkx/ffi";`);
+        }
         if (this.usedEnums.size > 0) {
             const enumList = Array.from(this.usedEnums).sort().join(", ");
             lines.push(`import { ${enumList} } from "./enums.js";`);
         }
+        for (const normalizedRecordName of Array.from(this.usedRecords).sort()) {
+            const normalizedCurrentClass = currentClassName ? normalizeClassName(currentClassName) : "";
+            const normalizedParentClass = parentClassName ? normalizeClassName(parentClassName) : "";
+            if (normalizedRecordName !== normalizedCurrentClass && normalizedRecordName !== normalizedParentClass) {
+                const originalName = this.recordNameToFile.get(normalizedRecordName) ?? normalizedRecordName;
+                lines.push(`import type { ${normalizedRecordName} } from "./${toKebabCase(originalName)}.js";`);
+            }
+        }
         for (const className of Array.from(this.signalClasses).sort()) {
             if (className !== currentClassName && className !== parentClassName) {
                 lines.push(`import { ${className} } from "./${toKebabCase(className)}.js";`);

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

@@ -0,0 +1,5 @@
+export declare class Context {
+    ptr: unknown;
+    constructor();
+    protected createPtr(_init: Record<string, unknown>): unknown;
+}

package/dist/generated/cairo/context.js

@@ -0,0 +1,9 @@
+export class Context {
+    ptr;
+    constructor() {
+        this.ptr = this.createPtr({});
+    }
+    createPtr(_init) {
+        return null;
+    }
+}

package/dist/generated/cairo/device.d.ts

@@ -0,0 +1,5 @@
+export declare class Device {
+    ptr: unknown;
+    constructor();
+    protected createPtr(_init: Record<string, unknown>): unknown;
+}

package/dist/generated/cairo/device.js

@@ -0,0 +1,9 @@
+export class Device {
+    ptr;
+    constructor() {
+        this.ptr = this.createPtr({});
+    }
+    createPtr(_init) {
+        return null;
+    }
+}

package/dist/generated/cairo/font-face.d.ts

@@ -0,0 +1,5 @@
+export declare class FontFace {
+    ptr: unknown;
+    constructor();
+    protected createPtr(_init: Record<string, unknown>): unknown;
+}

package/dist/generated/cairo/font-face.js

@@ -0,0 +1,9 @@
+export class FontFace {
+    ptr;
+    constructor() {
+        this.ptr = this.createPtr({});
+    }
+    createPtr(_init) {
+        return null;
+    }
+}

package/dist/generated/cairo/font-options.d.ts

@@ -0,0 +1,5 @@
+export declare class FontOptions {
+    ptr: unknown;
+    constructor();
+    protected createPtr(_init: Record<string, unknown>): unknown;
+}

package/dist/generated/cairo/font-options.js

@@ -0,0 +1,9 @@
+export class FontOptions {
+    ptr;
+    constructor() {
+        this.ptr = this.createPtr({});
+    }
+    createPtr(_init) {
+        return null;
+    }
+}

package/dist/generated/cairo/glyph.d.ts

@@ -0,0 +1,16 @@
+export interface GlyphInit {
+    index?: number;
+    x?: number;
+    y?: number;
+}
+export declare class Glyph {
+    ptr: unknown;
+    constructor(init?: GlyphInit);
+    protected createPtr(init: GlyphInit): unknown;
+    get index(): number;
+    set index(value: number);
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+}

package/dist/generated/cairo/glyph.js

@@ -0,0 +1,35 @@
+import { alloc, read, write } from "@gtkx/native";
+export class Glyph {
+    ptr;
+    constructor(init = {}) {
+        this.ptr = this.createPtr(init);
+    }
+    createPtr(init) {
+        const ptr = alloc(24, "CairoGlyph", "libcairo-gobject.so.2");
+        if (init.index !== undefined)
+            write(ptr, { type: "int", size: 64, unsigned: true }, 0, init.index);
+        if (init.x !== undefined)
+            write(ptr, { type: "float", size: 64 }, 8, init.x);
+        if (init.y !== undefined)
+            write(ptr, { type: "float", size: 64 }, 16, init.y);
+        return ptr;
+    }
+    get index() {
+        return read(this.ptr, { type: "int", size: 64, unsigned: true }, 0);
+    }
+    set index(value) {
+        write(this.ptr, { type: "int", size: 64, unsigned: true }, 0, value);
+    }
+    get x() {
+        return read(this.ptr, { type: "float", size: 64 }, 8);
+    }
+    set x(value) {
+        write(this.ptr, { type: "float", size: 64 }, 8, value);
+    }
+    get y() {
+        return read(this.ptr, { type: "float", size: 64 }, 16);
+    }
+    set y(value) {
+        write(this.ptr, { type: "float", size: 64 }, 16, value);
+    }
+}