@gtkx/ffi 0.13.3 → 0.15.0

package/dist/generated/webkitwebprocessextension/console-message.js

@@ -65,6 +65,8 @@ export class ConsoleMessage extends NativeObject {
             type: "int",
             size: 32,
             unsigned: false,
+            lib: "libwebkitgtk-6.0.so.4,libjavascriptcoregtk-6.0.so.1",
+            getTypeFn: "webkit_console_message_level_get_type",
         });
     }
     /** Gets the line number of a #WebKitConsoleMessage */
@@ -103,6 +105,8 @@ export class ConsoleMessage extends NativeObject {
             type: "int",
             size: 32,
             unsigned: false,
+            lib: "libwebkitgtk-6.0.so.4,libjavascriptcoregtk-6.0.so.1",
+            getTypeFn: "webkit_console_message_source_get_type",
         });
     }
     /** Gets the source identifier of a #WebKitConsoleMessage */

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

@@ -0,0 +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 Type of the value stored in this GValue.
+         * This is equivalent to the C macro G_VALUE_TYPE(value).
+         * @returns The Type identifier
+         */
+        getType(): number;
+        /**
+         * 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 Type.
+         * This is equivalent to G_VALUE_HOLDS(value, type).
+         * @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;
+    }
+}

package/dist/gobject/value.js

@@ -0,0 +1,106 @@
+import { read } from "@gtkx/native";
+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);
+};
+Value.prototype.getTypeName = function () {
+    const gtype = this.getType();
+    return typeName(gtype) ?? "invalid";
+};
+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/dist/index.d.ts

@@ -7,3 +7,4 @@ export * from "./native/lifecycle.js";
 export * from "./native/object.js";
 export * from "./registry.js";
 import "./cairo/cairo.js";
+import "./gobject/value.js";

package/dist/index.js

@@ -7,3 +7,4 @@ export * from "./native/lifecycle.js";
 export * from "./native/object.js";
 export * from "./registry.js";
 import "./cairo/cairo.js";
+import "./gobject/value.js";

package/dist/native/lifecycle.d.ts

@@ -2,6 +2,7 @@ import type { ApplicationFlags } from "../generated/gio/enums.js";
 import type { Application } from "../generated/gtk/application.js";
 /**
  * Checks if the GTK application runtime is currently running.
+ * Returns false in forked child processes where GTK state is invalid.
  *
  * @returns `true` if {@link start} has been called and {@link stop} has not
  */

package/dist/native/lifecycle.js

@@ -8,12 +8,14 @@ let keepAliveTimeout = null;
 let pollInterval = null;
 let application = null;
 let isStopping = false;
+let startedPid = null;
 /**
  * Checks if the GTK application runtime is currently running.
+ * Returns false in forked child processes where GTK state is invalid.
  *
  * @returns `true` if {@link start} has been called and {@link stop} has not
  */
-export const isStarted = () => application !== null;
+export const isStarted = () => startedPid === process.pid;
 const keepAlive = () => {
     keepAliveTimeout = setTimeout(() => keepAlive(), 2147483647);
 };
@@ -51,6 +53,7 @@ export const start = (appId, flags) => {
     if (application) {
         return application;
     }
+    startedPid = process.pid;
     const app = nativeStart(appId, flags);
     events.emit("start");
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/ffi",
-  "version": "0.13.3",
+  "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.13.3"
+    "@gtkx/native": "0.15.0"
   },
   "devDependencies": {
-    "@gtkx/vitest": "0.13.3"
+    "@gtkx/vitest": "0.15.0"
   },
   "scripts": {
     "build": "tsc -b && cp ../../README.md .",