@gtkx/ffi 0.14.0 → 0.15.0

package/dist/generated/vte/terminal.js

@@ -163,7 +163,7 @@ export class Terminal extends Gtk.Widget {
                     lengthParamIndex: 3,
                     ownership: "borrowed",
                 },
-                value: regexes,
+                value: regexes.map((item) => item.handle),
             },
             {
                 type: {
@@ -3579,7 +3579,7 @@ export class Terminal extends Gtk.Widget {
                     lengthParamIndex: 3,
                     ownership: "borrowed",
                 },
-                value: palette,
+                value: palette?.map((item) => item.handle),
                 optional: true,
             },
             {
@@ -5600,9 +5600,7 @@ export class Terminal extends Gtk.Widget {
      * shown when the user moves the mouse.
      */
     setPointerAutohide(value) {
-        const gvalue = new GObject.Value();
-        gvalue.init(GObject.typeFromName("gboolean"));
-        gvalue.setBoolean(value);
+        const gvalue = GObject.Value.newFromBoolean(value);
         call("libgobject-2.0.so.0", "g_object_set_property", [
             { type: { type: "gobject", ownership: "borrowed" }, value: this.handle },
             { type: { type: "string", ownership: "borrowed" }, value: "pointer-autohide" },

package/dist/generated/webkit/context-menu.js

@@ -69,7 +69,7 @@ export class ContextMenu extends GObject.GObject {
                     listType: "glist",
                     ownership: "borrowed",
                 },
-                value: items,
+                value: items.map((item) => item.handle),
                 optional: false,
             },
         ], {

package/dist/generated/webkit/cookie-manager.js

@@ -541,7 +541,7 @@ export class CookieManager extends GObject.GObject {
                         listType: "glist",
                         ownership: "borrowed",
                     },
-                    value: cookies,
+                    value: cookies.map((item) => item.handle),
                     optional: false,
                 },
                 {

package/dist/generated/webkit/web-context.js

@@ -267,7 +267,7 @@ export class WebContext extends GObject.GObject {
                     listType: "glist",
                     ownership: "borrowed",
                 },
-                value: allowedOrigins,
+                value: allowedOrigins.map((item) => item.handle),
             },
             {
                 type: {
@@ -282,7 +282,7 @@ export class WebContext extends GObject.GObject {
                     listType: "glist",
                     ownership: "borrowed",
                 },
-                value: disallowedOrigins,
+                value: disallowedOrigins.map((item) => item.handle),
             },
         ], {
             type: "undefined",

package/dist/generated/webkit/website-data-manager.js

@@ -455,7 +455,7 @@ export class WebsiteDataManager extends GObject.GObject {
                         listType: "glist",
                         ownership: "borrowed",
                     },
-                    value: websiteData,
+                    value: websiteData.map((item) => item.handle),
                     optional: false,
                 },
                 {

package/dist/generated/webkitwebprocessextension/context-menu.js

@@ -69,7 +69,7 @@ export class ContextMenu extends GObject.GObject {
                     listType: "glist",
                     ownership: "borrowed",
                 },
-                value: items,
+                value: items.map((item) => item.handle),
                 optional: false,
             },
         ], {

package/dist/gobject/index.d.ts

@@ -0,0 +1,3 @@
+export * from "../generated/gobject/index.js";
+export * from "./types.js";
+import "./value.js";

package/dist/gobject/index.js

@@ -0,0 +1,3 @@
+export * from "../generated/gobject/index.js";
+export * from "./types.js";
+import "./value.js";

package/dist/gobject/types.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Fundamental GLib type constants.
+ *
+ * Provides lazy-loaded GType identifiers for primitive and object types.
+ * Use with {@link Value} factory methods that require explicit type specification.
+ *
+ * @example
+ * ```ts
+ * import { Type, Value } from "@gtkx/ffi/gobject";
+ *
+ * const enumValue = Value.newFromEnum(myEnumGType, 0);
+ * console.log(Type.STRING); // GType for gchararray
+ * ```
+ */
+export declare const Type: {
+    readonly INVALID: number;
+    readonly NONE: number;
+    readonly INTERFACE: number;
+    readonly CHAR: number;
+    readonly UCHAR: number;
+    readonly BOOLEAN: number;
+    readonly INT: number;
+    readonly UINT: number;
+    readonly LONG: number;
+    readonly ULONG: number;
+    readonly INT64: number;
+    readonly UINT64: number;
+    readonly ENUM: number;
+    readonly FLAGS: number;
+    readonly FLOAT: number;
+    readonly DOUBLE: number;
+    readonly STRING: number;
+    readonly POINTER: number;
+    readonly BOXED: number;
+    readonly PARAM: number;
+    readonly OBJECT: number;
+    readonly VARIANT: number;
+};

package/dist/gobject/types.js

@@ -0,0 +1,127 @@
+import { typeFromName } from "../generated/gobject/functions.js";
+let invalidType;
+let noneType;
+let interfaceType;
+let charType;
+let ucharType;
+let booleanType;
+let intType;
+let uintType;
+let longType;
+let ulongType;
+let int64Type;
+let uint64Type;
+let enumType;
+let flagsType;
+let floatType;
+let doubleType;
+let stringType;
+let pointerType;
+let boxedType;
+let paramType;
+let objectType;
+let variantType;
+/**
+ * Fundamental GLib type constants.
+ *
+ * Provides lazy-loaded GType identifiers for primitive and object types.
+ * Use with {@link Value} factory methods that require explicit type specification.
+ *
+ * @example
+ * ```ts
+ * import { Type, Value } from "@gtkx/ffi/gobject";
+ *
+ * const enumValue = Value.newFromEnum(myEnumGType, 0);
+ * console.log(Type.STRING); // GType for gchararray
+ * ```
+ */
+export const Type = {
+    get INVALID() {
+        invalidType ??= typeFromName("void");
+        return invalidType;
+    },
+    get NONE() {
+        noneType ??= typeFromName("void");
+        return noneType;
+    },
+    get INTERFACE() {
+        interfaceType ??= typeFromName("GInterface");
+        return interfaceType;
+    },
+    get CHAR() {
+        charType ??= typeFromName("gchar");
+        return charType;
+    },
+    get UCHAR() {
+        ucharType ??= typeFromName("guchar");
+        return ucharType;
+    },
+    get BOOLEAN() {
+        booleanType ??= typeFromName("gboolean");
+        return booleanType;
+    },
+    get INT() {
+        intType ??= typeFromName("gint");
+        return intType;
+    },
+    get UINT() {
+        uintType ??= typeFromName("guint");
+        return uintType;
+    },
+    get LONG() {
+        longType ??= typeFromName("glong");
+        return longType;
+    },
+    get ULONG() {
+        ulongType ??= typeFromName("gulong");
+        return ulongType;
+    },
+    get INT64() {
+        int64Type ??= typeFromName("gint64");
+        return int64Type;
+    },
+    get UINT64() {
+        uint64Type ??= typeFromName("guint64");
+        return uint64Type;
+    },
+    get ENUM() {
+        enumType ??= typeFromName("GEnum");
+        return enumType;
+    },
+    get FLAGS() {
+        flagsType ??= typeFromName("GFlags");
+        return flagsType;
+    },
+    get FLOAT() {
+        floatType ??= typeFromName("gfloat");
+        return floatType;
+    },
+    get DOUBLE() {
+        doubleType ??= typeFromName("gdouble");
+        return doubleType;
+    },
+    get STRING() {
+        stringType ??= typeFromName("gchararray");
+        return stringType;
+    },
+    get POINTER() {
+        pointerType ??= typeFromName("gpointer");
+        return pointerType;
+    },
+    get BOXED() {
+        boxedType ??= typeFromName("GBoxed");
+        return boxedType;
+    },
+    get PARAM() {
+        paramType ??= typeFromName("GParam");
+        return paramType;
+    },
+    get OBJECT() {
+        objectType ??= typeFromName("GObject");
+        return objectType;
+    },
+    get VARIANT() {
+        variantType ??= typeFromName("GVariant");
+        return variantType;
+    },
+};

package/dist/gobject/value.d.ts

@@ -1,24 +1,101 @@
+import type { GObject } from "../generated/gobject/object.js";
+import type { NativeObject } from "../native/base.js";
 declare module "../generated/gobject/value.js" {
     interface Value {
         /**
-         * Gets the GType of the value stored in this GValue.
+         * Gets the Type of the value stored in this GValue.
          * This is equivalent to the C macro G_VALUE_TYPE(value).
-         * @returns The GType identifier
+         * @returns The Type identifier
          */
         getType(): number;
         /**
-         * Gets the name of the GType stored in this GValue.
+         * Gets the name of the Type stored in this GValue.
          * This is equivalent to G_VALUE_TYPE_NAME(value).
          * @returns The type name string
          */
         getTypeName(): string;
         /**
-         * Checks if this GValue holds a value of the specified GType.
+         * Checks if this GValue holds a value of the specified Type.
          * This is equivalent to G_VALUE_HOLDS(value, type).
-         * @param gtype - The GType to check against
+         * @param gtype - The Type to check against
          * @returns true if the value holds the specified type
          */
         holds(gtype: number): boolean;
     }
+    namespace Value {
+        /**
+         * Creates a GValue initialized with a boolean.
+         * @param value - The boolean value
+         */
+        function newFromBoolean(value: boolean): Value;
+        /**
+         * Creates a GValue initialized with a signed 32-bit integer.
+         * @param value - The integer value
+         */
+        function newFromInt(value: number): Value;
+        /**
+         * Creates a GValue initialized with an unsigned 32-bit integer.
+         * @param value - The unsigned integer value
+         */
+        function newFromUint(value: number): Value;
+        /**
+         * Creates a GValue initialized with a signed long integer.
+         * @param value - The long value
+         */
+        function newFromLong(value: number): Value;
+        /**
+         * Creates a GValue initialized with an unsigned long integer.
+         * @param value - The unsigned long value
+         */
+        function newFromUlong(value: number): Value;
+        /**
+         * Creates a GValue initialized with a signed 64-bit integer.
+         * @param value - The 64-bit integer value
+         */
+        function newFromInt64(value: number): Value;
+        /**
+         * Creates a GValue initialized with an unsigned 64-bit integer.
+         * @param value - The unsigned 64-bit integer value
+         */
+        function newFromUint64(value: number): Value;
+        /**
+         * Creates a GValue initialized with a 32-bit float.
+         * @param value - The float value
+         */
+        function newFromFloat(value: number): Value;
+        /**
+         * Creates a GValue initialized with a 64-bit double.
+         * @param value - The double value
+         */
+        function newFromDouble(value: number): Value;
+        /**
+         * Creates a GValue initialized with a string.
+         * @param value - The string value, or null
+         */
+        function newFromString(value: string | null): Value;
+        /**
+         * Creates a GValue initialized with a GObject instance.
+         * The GType is automatically determined from the object's class.
+         * @param value - The GObject instance, or null
+         */
+        function newFromObject(value: GObject | null): Value;
+        /**
+         * Creates a GValue initialized with a boxed type instance.
+         * The GType is automatically determined from the object's class.
+         * @param value - The boxed type instance (e.g., Gdk.RGBA, Graphene.Rect)
+         */
+        function newFromBoxed(value: NativeObject): Value;
+        /**
+         * Creates a GValue initialized with an enum value.
+         * @param gtype - The GType of the enum
+         * @param value - The enum value
+         */
+        function newFromEnum(gtype: number, value: number): Value;
+        /**
+         * Creates a GValue initialized with a flags value.
+         * @param gtype - The GType of the flags
+         * @param value - The flags value (can be combined with bitwise OR)
+         */
+        function newFromFlags(gtype: number, value: number): Value;
+    }
 }
-export {};

package/dist/gobject/value.js

@@ -1,6 +1,7 @@
 import { read } from "@gtkx/native";
-import { typeName } from "../generated/gobject/functions.js";
+import { typeFromName, typeName } from "../generated/gobject/functions.js";
 import { Value } from "../generated/gobject/value.js";
+import { Type } from "./types.js";
 Value.prototype.getType = function () {
     return read(this.handle, { type: "int", size: 64, unsigned: true }, 0);
 };
@@ -11,3 +12,95 @@ Value.prototype.getTypeName = function () {
 Value.prototype.holds = function (gtype) {
     return this.getType() === gtype;
 };
+const ValueWithStatics = Value;
+ValueWithStatics.newFromBoolean = (value) => {
+    const v = new Value();
+    v.init(Type.BOOLEAN);
+    v.setBoolean(value);
+    return v;
+};
+ValueWithStatics.newFromInt = (value) => {
+    const v = new Value();
+    v.init(Type.INT);
+    v.setInt(value);
+    return v;
+};
+ValueWithStatics.newFromUint = (value) => {
+    const v = new Value();
+    v.init(Type.UINT);
+    v.setUint(value);
+    return v;
+};
+ValueWithStatics.newFromLong = (value) => {
+    const v = new Value();
+    v.init(Type.LONG);
+    v.setLong(value);
+    return v;
+};
+ValueWithStatics.newFromUlong = (value) => {
+    const v = new Value();
+    v.init(Type.ULONG);
+    v.setUlong(value);
+    return v;
+};
+ValueWithStatics.newFromInt64 = (value) => {
+    const v = new Value();
+    v.init(Type.INT64);
+    v.setInt64(value);
+    return v;
+};
+ValueWithStatics.newFromUint64 = (value) => {
+    const v = new Value();
+    v.init(Type.UINT64);
+    v.setUint64(value);
+    return v;
+};
+ValueWithStatics.newFromFloat = (value) => {
+    const v = new Value();
+    v.init(Type.FLOAT);
+    v.setFloat(value);
+    return v;
+};
+ValueWithStatics.newFromDouble = (value) => {
+    const v = new Value();
+    v.init(Type.DOUBLE);
+    v.setDouble(value);
+    return v;
+};
+ValueWithStatics.newFromString = (value) => {
+    const v = new Value();
+    v.init(Type.STRING);
+    v.setString(value);
+    return v;
+};
+ValueWithStatics.newFromObject = (value) => {
+    const v = new Value();
+    if (value) {
+        const gtype = typeFromName(value.constructor.glibTypeName);
+        v.init(gtype);
+    }
+    else {
+        v.init(Type.OBJECT);
+    }
+    v.setObject(value);
+    return v;
+};
+ValueWithStatics.newFromBoxed = (value) => {
+    const v = new Value();
+    const gtype = typeFromName(value.constructor.glibTypeName);
+    v.init(gtype);
+    v.setBoxed(value.handle);
+    return v;
+};
+ValueWithStatics.newFromEnum = (gtype, value) => {
+    const v = new Value();
+    v.init(gtype);
+    v.setEnum(value);
+    return v;
+};
+ValueWithStatics.newFromFlags = (gtype, value) => {
+    const v = new Value();
+    v.init(gtype);
+    v.setFlags(value);
+    return v;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/ffi",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Generated TypeScript FFI bindings for GTKX",
   "keywords": [
     "gtkx",
@@ -38,6 +38,10 @@
       "types": "./dist/cairo/index.d.ts",
       "default": "./dist/cairo/index.js"
     },
+    "./gobject": {
+      "types": "./dist/gobject/index.d.ts",
+      "default": "./dist/gobject/index.js"
+    },
     "./*": {
       "types": "./dist/generated/*/index.d.ts",
       "default": "./dist/generated/*/index.js"
@@ -47,10 +51,10 @@
     "dist"
   ],
   "dependencies": {
-    "@gtkx/native": "0.14.0"
+    "@gtkx/native": "0.15.0"
   },
   "devDependencies": {
-    "@gtkx/vitest": "0.14.0"
+    "@gtkx/vitest": "0.15.0"
   },
   "scripts": {
     "build": "tsc -b && cp ../../README.md .",