@gtkx/codegen 0.21.0 → 1.0.0-rc.2

package/overrides/cairo/surface.ts.ejs

@@ -0,0 +1,296 @@
+import { type ExternalObject, getHandle, type Handle, t, wrapHandle } from "@gtkx/runtime";
+import type { Content, Format, RectangleInt, Status, SurfaceType } from "../cairo.js";
+import { Surface } from "../cairo.js";
+import { FontOptions } from "./font-options.js";
+import { ImageSurface } from "./image-surface.js";
+
+const { bind } = t;
+const SURFACE_T = t.boxed("CairoSurface", {
+    ownership: "borrowed",
+    sharedLibrary: "libcairo-gobject.so.2",
+    getTypeFnName: "cairo_gobject_surface_get_type",
+});
+const DEVICE_T_NONE = t.boxed("CairoDevice", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" });
+
+declare module "../cairo.js" {
+    interface Surface {
+        writeToPng(filename: string): Status;
+        status(): Status;
+        finish(): void;
+        flush(): void;
+        getDevice(): ExternalObject<Handle> | null;
+        getFontOptions(): FontOptions;
+        getContent(): Content;
+        markDirty(): void;
+        markDirtyRectangle(x: number, y: number, width: number, height: number): void;
+        setDeviceOffset(xOffset: number, yOffset: number): void;
+        getDeviceOffset(): { xOffset: number; yOffset: number };
+        getDeviceScale(): { xScale: number; yScale: number };
+        setDeviceScale(xScale: number, yScale: number): void;
+        setFallbackResolution(xPixelsPerInch: number, yPixelsPerInch: number): void;
+        getFallbackResolution(): { xPixelsPerInch: number; yPixelsPerInch: number };
+        getType(): SurfaceType;
+        getReferenceCount(): number;
+        copyPage(): void;
+        showPage(): void;
+        hasShowTextGlyphs(): boolean;
+        supportsMimeType(mimeType: string): boolean;
+        mapToImage(extents: RectangleInt): Surface;
+        unmapImage(image: Surface): void;
+    }
+
+    namespace Surface {
+        function createSimilar(other: Surface, content: Content, width: number, height: number): Surface;
+        function createSimilarImage(other: Surface, format: Format, width: number, height: number): Surface;
+        function createForRectangle(target: Surface, x: number, y: number, width: number, height: number): Surface;
+    }
+}
+
+type SurfaceStatic = {
+    createSimilar(other: Surface, content: Content, width: number, height: number): Surface;
+    createSimilarImage(other: Surface, format: Format, width: number, height: number): Surface;
+    createForRectangle(target: Surface, x: number, y: number, width: number, height: number): Surface;
+};
+
+const SurfaceWithStatics = Surface as typeof Surface & SurfaceStatic;
+
+const cairoSurfaceCreateSimilar = bind(
+    "libcairo.so.2",
+    "cairo_surface_create_similar",
+    [SURFACE_T, t.int32, t.int32, t.int32],
+    t.boxed("CairoSurface", {
+        ownership: "full",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_surface_get_type",
+    }),
+);
+SurfaceWithStatics.createSimilar = (other: Surface, content: Content, width: number, height: number): Surface => {
+    return wrapHandle(cairoSurfaceCreateSimilar(getHandle(other), content, width, height) as ExternalObject<Handle>, Surface);
+};
+
+const cairoSurfaceCreateSimilarImage = bind(
+    "libcairo.so.2",
+    "cairo_surface_create_similar_image",
+    [SURFACE_T, t.int32, t.int32, t.int32],
+    t.boxed("CairoSurface", {
+        ownership: "full",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_surface_get_type",
+    }),
+);
+SurfaceWithStatics.createSimilarImage = (other: Surface, format: Format, width: number, height: number): Surface => {
+    return wrapHandle(cairoSurfaceCreateSimilarImage(getHandle(other), format, width, height) as ExternalObject<Handle>, Surface);
+};
+
+const cairoSurfaceCreateForRectangle = bind(
+    "libcairo.so.2",
+    "cairo_surface_create_for_rectangle",
+    [SURFACE_T, t.float64, t.float64, t.float64, t.float64],
+    t.boxed("CairoSurface", {
+        ownership: "full",
+        sharedLibrary: "libcairo-gobject.so.2",
+        getTypeFnName: "cairo_gobject_surface_get_type",
+    }),
+);
+SurfaceWithStatics.createForRectangle = (
+    target: Surface,
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+): Surface => {
+    return wrapHandle(cairoSurfaceCreateForRectangle(getHandle(target), x, y, width, height) as ExternalObject<Handle>, Surface);
+};
+
+const cairoSurfaceWriteToPng = bind(
+    "libcairo.so.2",
+    "cairo_surface_write_to_png",
+    [SURFACE_T, t.string("full")],
+    t.int32,
+);
+Surface.prototype.writeToPng = function (filename: string): Status {
+    return cairoSurfaceWriteToPng(getHandle(this), filename) as Status;
+};
+
+const cairoSurfaceStatus = bind("libcairo.so.2", "cairo_surface_status", [SURFACE_T], t.int32);
+Surface.prototype.status = function (): Status {
+    return cairoSurfaceStatus(getHandle(this)) as Status;
+};
+
+const cairoSurfaceFinish = bind("libcairo.so.2", "cairo_surface_finish", [SURFACE_T], t.void);
+Surface.prototype.finish = function (): void {
+    cairoSurfaceFinish(getHandle(this));
+};
+
+const cairoSurfaceFlush = bind("libcairo.so.2", "cairo_surface_flush", [SURFACE_T], t.void);
+Surface.prototype.flush = function (): void {
+    cairoSurfaceFlush(getHandle(this));
+};
+
+const cairoSurfaceGetDevice = bind("libcairo.so.2", "cairo_surface_get_device", [SURFACE_T], DEVICE_T_NONE);
+Surface.prototype.getDevice = function (): ExternalObject<Handle> | null {
+    return cairoSurfaceGetDevice(getHandle(this)) as ExternalObject<Handle> | null;
+};
+
+const cairoSurfaceGetFontOptions = bind(
+    "libcairo.so.2",
+    "cairo_surface_get_font_options",
+    [
+        SURFACE_T,
+        t.boxed("CairoFontOptions", {
+            ownership: "borrowed",
+            sharedLibrary: "libcairo-gobject.so.2",
+            getTypeFnName: "cairo_gobject_font_options_get_type",
+        }),
+    ],
+    t.void,
+);
+Surface.prototype.getFontOptions = function (): FontOptions {
+    const options = FontOptions.create();
+    cairoSurfaceGetFontOptions(getHandle(this), getHandle(options));
+    return options;
+};
+
+const cairoSurfaceGetContent = bind("libcairo.so.2", "cairo_surface_get_content", [SURFACE_T], t.int32);
+Surface.prototype.getContent = function (): Content {
+    return cairoSurfaceGetContent(getHandle(this)) as Content;
+};
+
+const cairoSurfaceMarkDirty = bind("libcairo.so.2", "cairo_surface_mark_dirty", [SURFACE_T], t.void);
+Surface.prototype.markDirty = function (): void {
+    cairoSurfaceMarkDirty(getHandle(this));
+};
+
+const cairoSurfaceMarkDirtyRectangle = bind(
+    "libcairo.so.2",
+    "cairo_surface_mark_dirty_rectangle",
+    [SURFACE_T, t.int32, t.int32, t.int32, t.int32],
+    t.void,
+);
+Surface.prototype.markDirtyRectangle = function (x: number, y: number, width: number, height: number): void {
+    cairoSurfaceMarkDirtyRectangle(getHandle(this), x, y, width, height);
+};
+
+const cairoSurfaceSetDeviceOffset = bind(
+    "libcairo.so.2",
+    "cairo_surface_set_device_offset",
+    [SURFACE_T, t.float64, t.float64],
+    t.void,
+);
+Surface.prototype.setDeviceOffset = function (xOffset: number, yOffset: number): void {
+    cairoSurfaceSetDeviceOffset(getHandle(this), xOffset, yOffset);
+};
+
+const cairoSurfaceGetDeviceOffset = bind(
+    "libcairo.so.2",
+    "cairo_surface_get_device_offset",
+    [SURFACE_T, t.ref(t.float64), t.ref(t.float64)],
+    t.void,
+);
+Surface.prototype.getDeviceOffset = function (): { xOffset: number; yOffset: number } {
+    const xRef = { value: 0 };
+    const yRef = { value: 0 };
+    cairoSurfaceGetDeviceOffset(getHandle(this), xRef, yRef);
+    return { xOffset: xRef.value, yOffset: yRef.value };
+};
+
+const cairoSurfaceGetDeviceScale = bind(
+    "libcairo.so.2",
+    "cairo_surface_get_device_scale",
+    [SURFACE_T, t.ref(t.float64), t.ref(t.float64)],
+    t.void,
+);
+Surface.prototype.getDeviceScale = function (): { xScale: number; yScale: number } {
+    const xRef = { value: 0 };
+    const yRef = { value: 0 };
+    cairoSurfaceGetDeviceScale(getHandle(this), xRef, yRef);
+    return { xScale: xRef.value, yScale: yRef.value };
+};
+
+const cairoSurfaceSetDeviceScale = bind(
+    "libcairo.so.2",
+    "cairo_surface_set_device_scale",
+    [SURFACE_T, t.float64, t.float64],
+    t.void,
+);
+Surface.prototype.setDeviceScale = function (xScale: number, yScale: number): void {
+    cairoSurfaceSetDeviceScale(getHandle(this), xScale, yScale);
+};
+
+const cairoSurfaceSetFallbackResolution = bind(
+    "libcairo.so.2",
+    "cairo_surface_set_fallback_resolution",
+    [SURFACE_T, t.float64, t.float64],
+    t.void,
+);
+Surface.prototype.setFallbackResolution = function (xPixelsPerInch: number, yPixelsPerInch: number): void {
+    cairoSurfaceSetFallbackResolution(getHandle(this), xPixelsPerInch, yPixelsPerInch);
+};
+
+const cairoSurfaceGetFallbackResolution = bind(
+    "libcairo.so.2",
+    "cairo_surface_get_fallback_resolution",
+    [SURFACE_T, t.ref(t.float64), t.ref(t.float64)],
+    t.void,
+);
+Surface.prototype.getFallbackResolution = function (): { xPixelsPerInch: number; yPixelsPerInch: number } {
+    const xRef = { value: 0 };
+    const yRef = { value: 0 };
+    cairoSurfaceGetFallbackResolution(getHandle(this), xRef, yRef);
+    return { xPixelsPerInch: xRef.value, yPixelsPerInch: yRef.value };
+};
+
+const cairoSurfaceGetType = bind("libcairo.so.2", "cairo_surface_get_type", [SURFACE_T], t.int32);
+Surface.prototype.getType = function (): SurfaceType {
+    return cairoSurfaceGetType(getHandle(this)) as SurfaceType;
+};
+
+const cairoSurfaceGetReferenceCount = bind("libcairo.so.2", "cairo_surface_get_reference_count", [SURFACE_T], t.int32);
+Surface.prototype.getReferenceCount = function (): number {
+    return cairoSurfaceGetReferenceCount(getHandle(this)) as number;
+};
+
+const cairoSurfaceCopyPage = bind("libcairo.so.2", "cairo_surface_copy_page", [SURFACE_T], t.void);
+Surface.prototype.copyPage = function (): void {
+    cairoSurfaceCopyPage(getHandle(this));
+};
+
+const cairoSurfaceShowPage = bind("libcairo.so.2", "cairo_surface_show_page", [SURFACE_T], t.void);
+Surface.prototype.showPage = function (): void {
+    cairoSurfaceShowPage(getHandle(this));
+};
+
+const cairoSurfaceHasShowTextGlyphs = bind(
+    "libcairo.so.2",
+    "cairo_surface_has_show_text_glyphs",
+    [SURFACE_T],
+    t.boolean,
+);
+Surface.prototype.hasShowTextGlyphs = function (): boolean {
+    return cairoSurfaceHasShowTextGlyphs(getHandle(this)) as boolean;
+};
+
+const cairoSurfaceSupportsMimeType = bind(
+    "libcairo.so.2",
+    "cairo_surface_supports_mime_type",
+    [SURFACE_T, t.string("full")],
+    t.boolean,
+);
+Surface.prototype.supportsMimeType = function (mimeType: string): boolean {
+    return cairoSurfaceSupportsMimeType(getHandle(this), mimeType) as boolean;
+};
+
+const cairoSurfaceMapToImage = bind(
+    "libcairo.so.2",
+    "cairo_surface_map_to_image",
+    [SURFACE_T, t.boxed("cairo_rectangle_int_t", { ownership: "borrowed", sharedLibrary: "libcairo.so.2" })],
+    SURFACE_T,
+);
+Surface.prototype.mapToImage = function (extents: RectangleInt): Surface {
+    return wrapHandle(cairoSurfaceMapToImage(getHandle(this), getHandle(extents)) as ExternalObject<Handle>, ImageSurface);
+};
+
+const cairoSurfaceUnmapImage = bind("libcairo.so.2", "cairo_surface_unmap_image", [SURFACE_T, SURFACE_T], t.void);
+Surface.prototype.unmapImage = function (image: Surface): void {
+    cairoSurfaceUnmapImage(getHandle(this), getHandle(image));
+};

package/overrides/gdk/index.ts.ejs

@@ -0,0 +1,2 @@
+export * from "./gdk.js";
+export { RGBA } from "./overrides/rgba.js";

package/overrides/gdk/rgba.ts.ejs

@@ -0,0 +1,11 @@
+import { RGBA as GeneratedRGBA } from "../gdk.js";
+
+const create = (value: string): GeneratedRGBA => {
+    const rgba = new GeneratedRGBA();
+    rgba.parse(value);
+    return rgba;
+};
+
+export const RGBA: typeof GeneratedRGBA & { create: typeof create } = Object.assign(GeneratedRGBA, { create });
+
+export type RGBA = GeneratedRGBA;

package/overrides/gobject/index.ts.ejs

@@ -0,0 +1,29 @@
+export {
+    TYPE_BOOLEAN,
+    TYPE_BOXED,
+    TYPE_CHAR,
+    TYPE_DOUBLE,
+    TYPE_ENUM,
+    TYPE_FLAGS,
+    TYPE_FLOAT,
+    TYPE_GTYPE,
+    TYPE_INT,
+    TYPE_INT64,
+    TYPE_INTERFACE,
+    TYPE_INVALID,
+    TYPE_LONG,
+    TYPE_NONE,
+    TYPE_OBJECT,
+    TYPE_PARAM,
+    TYPE_POINTER,
+    TYPE_STRING,
+    TYPE_UCHAR,
+    TYPE_UINT,
+    TYPE_UINT64,
+    TYPE_ULONG,
+    TYPE_UNICHAR,
+    TYPE_VARIANT,
+} from "@gtkx/runtime";
+export * from "./gobject.js";
+export * from "./overrides/object.js";
+export * from "./overrides/value.js";

package/overrides/gobject/object.ts.ejs

@@ -0,0 +1,51 @@
+import { offSignal, onceSignal, onSignal } from "@gtkx/runtime";
+import { Object as GObject, signalHandlerDisconnect, type Type } from "../gobject.js";
+
+type Listener = (...args: unknown[]) => unknown;
+
+declare module "../gobject.js" {
+    interface Object {
+        __type__: Type;
+
+        disconnect(handlerId: number): void;
+
+        on(sigName: string, callback: (...args: unknown[]) => unknown, after?: boolean): Object;
+
+        once(sigName: string, callback: (...args: unknown[]) => unknown, after?: boolean): Object;
+
+        off(sigName: string, callback: (...args: unknown[]) => unknown): Object;
+
+        addEventListener(sigName: string, callback: (...args: unknown[]) => unknown, after?: boolean): Object;
+
+        removeEventListener(sigName: string, callback: (...args: unknown[]) => unknown): Object;
+    }
+}
+
+type GObjectWithConnect = GObject & {
+    connect(sigName: string, callback: Listener, after?: boolean): number;
+};
+
+GObject.prototype.disconnect = function disconnect(handlerId: number): void {
+    signalHandlerDisconnect(this, BigInt(handlerId));
+};
+
+function onImpl(this: GObjectWithConnect, sigName: string, callback: Listener, after?: boolean): GObject {
+    onSignal(this, sigName, callback, after);
+    return this;
+}
+GObject.prototype.on = onImpl;
+
+function onceImpl(this: GObjectWithConnect, sigName: string, callback: Listener, after?: boolean): GObject {
+    onceSignal(this, sigName, callback, after);
+    return this;
+}
+GObject.prototype.once = onceImpl;
+
+function offImpl(this: GObjectWithConnect, sigName: string, callback: Listener): GObject {
+    offSignal(this, sigName, callback);
+    return this;
+}
+GObject.prototype.off = offImpl;
+
+GObject.prototype.addEventListener = onImpl;
+GObject.prototype.removeEventListener = offImpl;

package/overrides/gobject/value.ts.ejs

@@ -0,0 +1,17 @@
+import { getBoxedValue, getHandle, setBoxedValue } from "@gtkx/runtime";
+import { type Type, Value } from "../gobject.js";
+
+export const buildValue = (gtype: Type, populate: (value: Value) => void): Value => {
+    const value = new Value();
+    value.init(gtype);
+    populate(value);
+    return value;
+};
+
+Value.prototype.getBoxed = function <T = unknown>(this: Value): T {
+    return getBoxedValue(getHandle(this)) as T;
+};
+
+Value.prototype.setBoxed = function (this: Value, boxed: object | null): void {
+    setBoxedValue(getHandle(this), boxed);
+};

package/overrides/graphene/index.ts.ejs

@@ -0,0 +1,2 @@
+export * from "./graphene.js";
+export { Point, Rect, Size } from "./overrides/structs.js";

package/overrides/graphene/structs.ts.ejs

@@ -0,0 +1,37 @@
+import { Point as GeneratedPoint, Rect as GeneratedRect, Size as GeneratedSize } from "../graphene.js";
+
+const createPoint = (x: number, y: number): GeneratedPoint => {
+    const point = GeneratedPoint.alloc();
+    point.init(x, y);
+    return point;
+};
+
+const createRect = (x: number, y: number, width: number, height: number): GeneratedRect => {
+    const rect = GeneratedRect.alloc();
+    rect.init(x, y, width, height);
+    return rect;
+};
+
+const createSize = (width: number, height: number): GeneratedSize => {
+    const size = GeneratedSize.alloc();
+    size.init(width, height);
+    return size;
+};
+
+export const Point: typeof GeneratedPoint & { create: typeof createPoint } = Object.assign(GeneratedPoint, {
+    create: createPoint,
+});
+
+export type Point = GeneratedPoint;
+
+export const Rect: typeof GeneratedRect & { create: typeof createRect } = Object.assign(GeneratedRect, {
+    create: createRect,
+});
+
+export type Rect = GeneratedRect;
+
+export const Size: typeof GeneratedSize & { create: typeof createSize } = Object.assign(GeneratedSize, {
+    create: createSize,
+});
+
+export type Size = GeneratedSize;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gtkx/codegen",
-  "version": "0.21.0",
-  "description": "GIR-driven TypeScript code generator for GTKX FFI and React bindings",
+  "version": "1.0.0-rc.2",
+  "description": "Generates the typed GTKX bindings and API reference from GIR and OpenGL registry data",
   "keywords": [
     "gtkx",
     "gtk",
@@ -17,7 +17,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/gtkx-org/gtkx.git",
+    "url": "git+https://github.com/gtkx-org/gtkx.git",
     "directory": "packages/codegen"
   },
   "license": "MPL-2.0",
@@ -26,30 +26,36 @@
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "source": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./gi": {
+      "types": "./dist/gi.d.ts",
+      "default": "./dist/gi.js"
+    },
+    "./jsx": {
+      "types": "./dist/jsx.d.ts",
+      "default": "./dist/jsx.js"
     }
   },
   "sideEffects": false,
   "files": [
     "dist",
+    "overrides",
     "src"
   ],
-  "dependencies": {
-    "fast-xml-parser": "^5.8.0",
-    "typescript": "^6.0.3",
-    "@gtkx/utils": "0.21.0"
-  },
-  "devDependencies": {
-    "@types/node": "^25.9.1"
-  },
   "engines": {
     "node": ">=24"
   },
+  "dependencies": {
+    "@types/node": "^26.1.2",
+    "fast-xml-parser": "^5.10.1",
+    "typescript": "^6.0.3",
+    "@gtkx/config": "1.0.0-rc.2",
+    "@gtkx/react": "1.0.0-rc.2",
+    "@gtkx/utils": "1.0.0-rc.2"
+  },
   "scripts": {
-    "build": "tsc -b",
-    "test": "vitest run",
-    "typecheck": "tsc -b --emitDeclarationOnly"
+    "release": "tsx ../../scripts/release-package.ts"
   }
 }