@gtkx/ffi 0.1.45 → 0.1.47

package/README.md

@@ -68,7 +68,7 @@ export const App = () => {
       defaultHeight={300}
       onCloseRequest={quit}
     >
-      <Box orientation={Orientation.VERTICAL} spacing={12} margin={20}>
+      <Box orientation={Orientation.VERTICAL} spacing={12} marginStart={20} marginEnd={20} marginTop={20} marginBottom={20}>
         <Label.Root label={`Count: ${count}`} />
         <Button
           label="Increment"

package/dist/cairo/cairo.d.ts

@@ -1,30 +1,133 @@
+/**
+ * Cairo drawing function bindings via libcairo.
+ * These wrap Cairo calls for use in GtkDrawingArea draw callbacks.
+ */
+/**
+ * Begin a new sub-path. After this call the current point will be (x, y).
+ */
 export declare function moveTo(cr: unknown, x: number, y: number): void;
+/**
+ * Adds a line to the path from the current point to position (x, y).
+ */
 export declare function lineTo(cr: unknown, x: number, y: number): void;
+/**
+ * Adds a cubic Bezier spline to the path.
+ */
 export declare function curveTo(cr: unknown, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): void;
+/**
+ * Adds a circular arc to the current path.
+ * @param xc - X position of the center of the arc
+ * @param yc - Y position of the center of the arc
+ * @param radius - The radius of the arc
+ * @param angle1 - The start angle, in radians
+ * @param angle2 - The end angle, in radians
+ */
 export declare function arc(cr: unknown, xc: number, yc: number, radius: number, angle1: number, angle2: number): void;
+/**
+ * Adds a circular arc to the current path (counter-clockwise).
+ */
 export declare function arcNegative(cr: unknown, xc: number, yc: number, radius: number, angle1: number, angle2: number): void;
+/**
+ * Adds a closed sub-path rectangle to the current path.
+ */
 export declare function rectangle(cr: unknown, x: number, y: number, width: number, height: number): void;
+/**
+ * Adds a line segment to the path from the current point to the beginning of the current sub-path.
+ */
 export declare function closePath(cr: unknown): void;
+/**
+ * Clears the current path.
+ */
 export declare function newPath(cr: unknown): void;
+/**
+ * Begin a new sub-path without clearing the current path.
+ */
 export declare function newSubPath(cr: unknown): void;
+/**
+ * Stroke the current path according to the current line width, line join, line cap, and dash settings.
+ */
 export declare function stroke(cr: unknown): void;
+/**
+ * Stroke the current path but preserve the path for further use.
+ */
 export declare function strokePreserve(cr: unknown): void;
+/**
+ * Fill the current path according to the current fill rule.
+ */
 export declare function fill(cr: unknown): void;
+/**
+ * Fill the current path but preserve the path for further use.
+ */
 export declare function fillPreserve(cr: unknown): void;
+/**
+ * Paint the current source everywhere within the current clip region.
+ */
 export declare function paint(cr: unknown): void;
+/**
+ * Paint the current source using alpha as a mask.
+ */
 export declare function paintWithAlpha(cr: unknown, alpha: number): void;
+/**
+ * Sets the source pattern to an opaque color (RGB).
+ */
 export declare function setSourceRgb(cr: unknown, red: number, green: number, blue: number): void;
+/**
+ * Sets the source pattern to a translucent color (RGBA).
+ */
 export declare function setSourceRgba(cr: unknown, red: number, green: number, blue: number, alpha: number): void;
+/**
+ * Sets the current line width.
+ */
 export declare function setLineWidth(cr: unknown, width: number): void;
+/**
+ * Sets the current line cap style.
+ * @param lineCap - 0 = BUTT, 1 = ROUND, 2 = SQUARE
+ */
 export declare function setLineCap(cr: unknown, lineCap: number): void;
+/**
+ * Sets the current line join style.
+ * @param lineJoin - 0 = MITER, 1 = ROUND, 2 = BEVEL
+ */
 export declare function setLineJoin(cr: unknown, lineJoin: number): void;
+/**
+ * Sets the dash pattern to be used by stroke.
+ */
 export declare function setDash(cr: unknown, dashes: number[], offset: number): void;
+/**
+ * Makes a copy of the current state and saves it on an internal stack.
+ */
 export declare function save(cr: unknown): void;
+/**
+ * Restores the state saved by a preceding call to save().
+ */
 export declare function restore(cr: unknown): void;
+/**
+ * Modifies the current transformation matrix by translating.
+ */
 export declare function translate(cr: unknown, tx: number, ty: number): void;
+/**
+ * Modifies the current transformation matrix by scaling.
+ */
 export declare function scale(cr: unknown, sx: number, sy: number): void;
+/**
+ * Modifies the current transformation matrix by rotating.
+ * @param angle - Angle of rotation in radians
+ */
 export declare function rotate(cr: unknown, angle: number): void;
+/**
+ * Establishes a new clip region by intersecting the current clip region with the current path.
+ */
 export declare function clip(cr: unknown): void;
+/**
+ * Establishes a new clip region but preserves the path for further use.
+ */
 export declare function clipPreserve(cr: unknown): void;
+/**
+ * Reset the current clip region to its original, unrestricted state.
+ */
 export declare function resetClip(cr: unknown): void;
+/**
+ * Sets the compositing operator.
+ * @param op - Operator constant (e.g., CAIRO_OPERATOR_OVER = 2)
+ */
 export declare function setOperator(cr: unknown, op: number): void;

package/dist/cairo/cairo.js

@@ -1,6 +1,13 @@
+/**
+ * Cairo drawing function bindings via libcairo.
+ * These wrap Cairo calls for use in GtkDrawingArea draw callbacks.
+ */
 import { call } from "@gtkx/native";
 const LIB = "libcairo.so.2";
 const CAIRO_T = { type: "int", size: 64, unsigned: true };
+/**
+ * Begin a new sub-path. After this call the current point will be (x, y).
+ */
 export function moveTo(cr, x, y) {
     call(LIB, "cairo_move_to", [
         { type: CAIRO_T, value: cr },
@@ -8,6 +15,9 @@ export function moveTo(cr, x, y) {
         { type: { type: "float", size: 64 }, value: y },
     ], { type: "undefined" });
 }
+/**
+ * Adds a line to the path from the current point to position (x, y).
+ */
 export function lineTo(cr, x, y) {
     call(LIB, "cairo_line_to", [
         { type: CAIRO_T, value: cr },
@@ -15,6 +25,9 @@ export function lineTo(cr, x, y) {
         { type: { type: "float", size: 64 }, value: y },
     ], { type: "undefined" });
 }
+/**
+ * Adds a cubic Bezier spline to the path.
+ */
 export function curveTo(cr, x1, y1, x2, y2, x3, y3) {
     call(LIB, "cairo_curve_to", [
         { type: CAIRO_T, value: cr },
@@ -26,6 +39,14 @@ export function curveTo(cr, x1, y1, x2, y2, x3, y3) {
         { type: { type: "float", size: 64 }, value: y3 },
     ], { type: "undefined" });
 }
+/**
+ * Adds a circular arc to the current path.
+ * @param xc - X position of the center of the arc
+ * @param yc - Y position of the center of the arc
+ * @param radius - The radius of the arc
+ * @param angle1 - The start angle, in radians
+ * @param angle2 - The end angle, in radians
+ */
 export function arc(cr, xc, yc, radius, angle1, angle2) {
     call(LIB, "cairo_arc", [
         { type: CAIRO_T, value: cr },
@@ -36,6 +57,9 @@ export function arc(cr, xc, yc, radius, angle1, angle2) {
         { type: { type: "float", size: 64 }, value: angle2 },
     ], { type: "undefined" });
 }
+/**
+ * Adds a circular arc to the current path (counter-clockwise).
+ */
 export function arcNegative(cr, xc, yc, radius, angle1, angle2) {
     call(LIB, "cairo_arc_negative", [
         { type: CAIRO_T, value: cr },
@@ -46,6 +70,9 @@ export function arcNegative(cr, xc, yc, radius, angle1, angle2) {
         { type: { type: "float", size: 64 }, value: angle2 },
     ], { type: "undefined" });
 }
+/**
+ * Adds a closed sub-path rectangle to the current path.
+ */
 export function rectangle(cr, x, y, width, height) {
     call(LIB, "cairo_rectangle", [
         { type: CAIRO_T, value: cr },
@@ -55,36 +82,66 @@ export function rectangle(cr, x, y, width, height) {
         { type: { type: "float", size: 64 }, value: height },
     ], { type: "undefined" });
 }
+/**
+ * Adds a line segment to the path from the current point to the beginning of the current sub-path.
+ */
 export function closePath(cr) {
     call(LIB, "cairo_close_path", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
 }
+/**
+ * Clears the current path.
+ */
 export function newPath(cr) {
     call(LIB, "cairo_new_path", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
 }
+/**
+ * Begin a new sub-path without clearing the current path.
+ */
 export function newSubPath(cr) {
     call(LIB, "cairo_new_sub_path", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
 }
+/**
+ * Stroke the current path according to the current line width, line join, line cap, and dash settings.
+ */
 export function stroke(cr) {
     call(LIB, "cairo_stroke", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
 }
+/**
+ * Stroke the current path but preserve the path for further use.
+ */
 export function strokePreserve(cr) {
     call(LIB, "cairo_stroke_preserve", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
 }
+/**
+ * Fill the current path according to the current fill rule.
+ */
 export function fill(cr) {
     call(LIB, "cairo_fill", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
 }
+/**
+ * Fill the current path but preserve the path for further use.
+ */
 export function fillPreserve(cr) {
     call(LIB, "cairo_fill_preserve", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
 }
+/**
+ * Paint the current source everywhere within the current clip region.
+ */
 export function paint(cr) {
     call(LIB, "cairo_paint", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
 }
+/**
+ * Paint the current source using alpha as a mask.
+ */
 export function paintWithAlpha(cr, alpha) {
     call(LIB, "cairo_paint_with_alpha", [
         { type: CAIRO_T, value: cr },
         { type: { type: "float", size: 64 }, value: alpha },
     ], { type: "undefined" });
 }
+/**
+ * Sets the source pattern to an opaque color (RGB).
+ */
 export function setSourceRgb(cr, red, green, blue) {
     call(LIB, "cairo_set_source_rgb", [
         { type: CAIRO_T, value: cr },
@@ -93,6 +150,9 @@ export function setSourceRgb(cr, red, green, blue) {
         { type: { type: "float", size: 64 }, value: blue },
     ], { type: "undefined" });
 }
+/**
+ * Sets the source pattern to a translucent color (RGBA).
+ */
 export function setSourceRgba(cr, red, green, blue, alpha) {
     call(LIB, "cairo_set_source_rgba", [
         { type: CAIRO_T, value: cr },
@@ -102,24 +162,38 @@ export function setSourceRgba(cr, red, green, blue, alpha) {
         { type: { type: "float", size: 64 }, value: alpha },
     ], { type: "undefined" });
 }
+/**
+ * Sets the current line width.
+ */
 export function setLineWidth(cr, width) {
     call(LIB, "cairo_set_line_width", [
         { type: CAIRO_T, value: cr },
         { type: { type: "float", size: 64 }, value: width },
     ], { type: "undefined" });
 }
+/**
+ * Sets the current line cap style.
+ * @param lineCap - 0 = BUTT, 1 = ROUND, 2 = SQUARE
+ */
 export function setLineCap(cr, lineCap) {
     call(LIB, "cairo_set_line_cap", [
         { type: CAIRO_T, value: cr },
         { type: { type: "int", size: 32, unsigned: false }, value: lineCap },
     ], { type: "undefined" });
 }
+/**
+ * Sets the current line join style.
+ * @param lineJoin - 0 = MITER, 1 = ROUND, 2 = BEVEL
+ */
 export function setLineJoin(cr, lineJoin) {
     call(LIB, "cairo_set_line_join", [
         { type: CAIRO_T, value: cr },
         { type: { type: "int", size: 32, unsigned: false }, value: lineJoin },
     ], { type: "undefined" });
 }
+/**
+ * Sets the dash pattern to be used by stroke.
+ */
 export function setDash(cr, dashes, offset) {
     call(LIB, "cairo_set_dash", [
         { type: CAIRO_T, value: cr },
@@ -128,12 +202,21 @@ export function setDash(cr, dashes, offset) {
         { type: { type: "float", size: 64 }, value: offset },
     ], { type: "undefined" });
 }
+/**
+ * Makes a copy of the current state and saves it on an internal stack.
+ */
 export function save(cr) {
     call(LIB, "cairo_save", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
 }
+/**
+ * Restores the state saved by a preceding call to save().
+ */
 export function restore(cr) {
     call(LIB, "cairo_restore", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
 }
+/**
+ * Modifies the current transformation matrix by translating.
+ */
 export function translate(cr, tx, ty) {
     call(LIB, "cairo_translate", [
         { type: CAIRO_T, value: cr },
@@ -141,6 +224,9 @@ export function translate(cr, tx, ty) {
         { type: { type: "float", size: 64 }, value: ty },
     ], { type: "undefined" });
 }
+/**
+ * Modifies the current transformation matrix by scaling.
+ */
 export function scale(cr, sx, sy) {
     call(LIB, "cairo_scale", [
         { type: CAIRO_T, value: cr },
@@ -148,21 +234,38 @@ export function scale(cr, sx, sy) {
         { type: { type: "float", size: 64 }, value: sy },
     ], { type: "undefined" });
 }
+/**
+ * Modifies the current transformation matrix by rotating.
+ * @param angle - Angle of rotation in radians
+ */
 export function rotate(cr, angle) {
     call(LIB, "cairo_rotate", [
         { type: CAIRO_T, value: cr },
         { type: { type: "float", size: 64 }, value: angle },
     ], { type: "undefined" });
 }
+/**
+ * Establishes a new clip region by intersecting the current clip region with the current path.
+ */
 export function clip(cr) {
     call(LIB, "cairo_clip", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
 }
+/**
+ * Establishes a new clip region but preserves the path for further use.
+ */
 export function clipPreserve(cr) {
     call(LIB, "cairo_clip_preserve", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
 }
+/**
+ * Reset the current clip region to its original, unrestricted state.
+ */
 export function resetClip(cr) {
     call(LIB, "cairo_reset_clip", [{ type: CAIRO_T, value: cr }], { type: "undefined" });
 }
+/**
+ * Sets the compositing operator.
+ * @param op - Operator constant (e.g., CAIRO_OPERATOR_OVER = 2)
+ */
 export function setOperator(cr, op) {
     call(LIB, "cairo_set_operator", [
         { type: CAIRO_T, value: cr },

package/dist/cairo/index.d.ts

@@ -1,2 +1,15 @@
+/**
+ * Cairo drawing bindings for use with GtkDrawingArea.
+ *
+ * Example usage:
+ * ```typescript
+ * import * as cairo from "@gtkx/ffi/cairo";
+ *
+ * // In a draw callback:
+ * cairo.setSourceRgba(cr, 0.2, 0.4, 0.8, 1.0);
+ * cairo.arc(cr, width / 2, height / 2, 50, 0, 2 * Math.PI);
+ * cairo.fill(cr);
+ * ```
+ */
 export * from "../generated/cairo/index.js";
 export * from "./cairo.js";

package/dist/cairo/index.js

@@ -1,2 +1,15 @@
+/**
+ * Cairo drawing bindings for use with GtkDrawingArea.
+ *
+ * Example usage:
+ * ```typescript
+ * import * as cairo from "@gtkx/ffi/cairo";
+ *
+ * // In a draw callback:
+ * cairo.setSourceRgba(cr, 0.2, 0.4, 0.8, 1.0);
+ * cairo.arc(cr, width / 2, height / 2, 50, 0, 2 * Math.PI);
+ * cairo.fill(cr);
+ * ```
+ */
 export * from "../generated/cairo/index.js";
 export * from "./cairo.js";

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

@@ -1,10 +1,22 @@
 import type { GirNamespace, TypeRegistry } from "@gtkx/gir";
+/**
+ * Configuration options for the FFI code generator.
+ */
 interface GeneratorOptions {
+    /** Output directory for generated files. */
     outputDir: string;
+    /** The namespace being generated (e.g., "Gtk"). */
     namespace: string;
+    /** Optional Prettier configuration for formatting output. */
     prettierConfig?: unknown;
+    /** Optional type registry for cross-namespace type resolution. */
     typeRegistry?: TypeRegistry;
 }
+/**
+ * Generates TypeScript FFI bindings from GIR namespace definitions.
+ * Creates classes, methods, properties, and signal handlers that call
+ * native GTK functions through the FFI bridge.
+ */
 export declare class CodeGenerator {
     private options;
     private typeMapper;
@@ -28,7 +40,16 @@ export declare class CodeGenerator {
     private interfaceNameToFile;
     private currentSharedLibrary;
     private cyclicReturnTypes;
+    /**
+     * Creates a new code generator with the given options.
+     * @param options - Generator configuration
+     */
     constructor(options: GeneratorOptions);
+    /**
+     * Generates TypeScript files for all types in a GIR namespace.
+     * @param namespace - The parsed GIR namespace
+     * @returns Map of filename to generated TypeScript code
+     */
     generateNamespace(namespace: GirNamespace): Promise<Map<string, string>>;
     private registerEnumsAndBitfields;
     private registerRecords;

package/dist/codegen/ffi-generator.js

@@ -207,6 +207,11 @@ const cTypeToGetTypeFunc = (cType) => {
     const snakeCase = cType.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
     return `${snakeCase}_get_type`;
 };
+/**
+ * Generates TypeScript FFI bindings from GIR namespace definitions.
+ * Creates classes, methods, properties, and signal handlers that call
+ * native GTK functions through the FFI bridge.
+ */
 export class CodeGenerator {
     options;
     typeMapper;
@@ -230,6 +235,10 @@ export class CodeGenerator {
     interfaceNameToFile = new Map();
     currentSharedLibrary = "";
     cyclicReturnTypes = new Set();
+    /**
+     * Creates a new code generator with the given options.
+     * @param options - Generator configuration
+     */
     constructor(options) {
         this.options = options;
         this.typeMapper = new TypeMapper();
@@ -237,6 +246,11 @@ export class CodeGenerator {
             this.typeMapper.setTypeRegistry(options.typeRegistry, options.namespace);
         }
     }
+    /**
+     * Generates TypeScript files for all types in a GIR namespace.
+     * @param namespace - The parsed GIR namespace
+     * @returns Map of filename to generated TypeScript code
+     */
     async generateNamespace(namespace) {
         const files = new Map();
         this.currentSharedLibrary = namespace.sharedLibrary;

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

@@ -1,13 +1,87 @@
 import { Display } from "./display.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
+/**
+ * Handles launching an application in a graphical context.
+ *
+ * It is an implementation of `GAppLaunchContext` that provides startup
+ * notification and allows to launch applications on a specific workspace.
+ *
+ * ## Launching an application
+ *
+ * ```c
+ * GdkAppLaunchContext *context;
+ *
+ * context = gdk_display_get_app_launch_context (display);
+ *
+ * gdk_app_launch_context_set_timestamp (gdk_event_get_time (event));
+ *
+ * if (!g_app_info_launch_default_for_uri ("http://www.gtk.org", context, &error))
+ * g_warning ("Launching failed: %s\n", error->message);
+ *
+ * g_object_unref (context);
+ * ```
+ */
 export declare class AppLaunchContext extends Gio.AppLaunchContext {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Gets the `GdkDisplay` that `context` is for.
+     */
     getGdkDisplay(): Display;
+    /**
+     * Sets the workspace on which applications will be launched.
+     *
+     * This only works when running under a window manager that
+     * supports multiple workspaces, as described in the
+     * [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec).
+     * Specifically this sets the `_NET_WM_DESKTOP` property described
+     * in that spec.
+     *
+     * This only works when using the X11 backend.
+     *
+     * When the workspace is not specified or `desktop` is set to -1,
+     * it is up to the window manager to pick one, typically it will
+     * be the current workspace.
+     * @param desktop - the number of a workspace, or -1
+     */
     setDesktop(desktop: number): void;
+    /**
+     * Sets the icon for applications that are launched with this
+     * context.
+     *
+     * Window Managers can use this information when displaying startup
+     * notification.
+     *
+     * See also [method@Gdk.AppLaunchContext.set_icon_name].
+     * @param icon - a `GIcon`
+     */
     setIcon(icon?: Gio.Icon | null): void;
+    /**
+     * Sets the icon for applications that are launched with this context.
+     *
+     * The `icon_name` will be interpreted in the same way as the Icon field
+     * in desktop files. See also [method@Gdk.AppLaunchContext.set_icon].
+     *
+     * If both `icon` and `icon_name` are set, the `icon_name` takes priority.
+     * If neither `icon` or `icon_name` is set, the icon is taken from either
+     * the file that is passed to launched application or from the `GAppInfo`
+     * for the launched application itself.
+     * @param iconName - an icon name
+     */
     setIconName(iconName?: string | null): void;
+    /**
+     * Sets the timestamp of @context.
+     *
+     * The timestamp should ideally be taken from the event that
+     * triggered the launch.
+     *
+     * Window managers can use this information to avoid moving the
+     * focus to the newly launched application when the user is busy
+     * typing in another window. This is also known as 'focus stealing
+     * prevention'.
+     * @param timestamp - a timestamp
+     */
     setTimestamp(timestamp: number): void;
     connect(signal: "notify", handler: (self: AppLaunchContext, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;