@ts-for-gir/cli 3.0.0-beta.2

package/templates/Gjs/GObject-2.0.d.ts

@@ -0,0 +1,238 @@
+// A few things here are inspired by gi.ts 
+// See https://gitlab.gnome.org/ewlsh/gi.ts/-/blob/master/packages/lib/src/generators/dts/gobject.ts
+// Copyright Evan Welsh
+
+export type GType<T = unknown> = {
+    __type__(arg: never): T
+    name: string
+};
+
+// Extra interfaces used to help define GObject classes in js; these
+// aren't part of gi.
+export interface SignalDefinition {
+    flags?: SignalFlags
+    accumulator: number
+    return_type?: GType
+    param_types?: GType[]
+}
+
+export interface MetaInfo<Props, Interfaces, Sigs> {
+    GTypeName?: string
+    GTypeFlags?: TypeFlags
+    Properties?: Props
+    Signals?: Sigs
+    Implements?: Interfaces
+    CssName?: string
+    Template?: Uint8Array | GLib.Bytes
+    Children?: string[]
+    InternalChildren?: string[]
+}
+
+/** Interface of GObject Interface should be implemented by all GObject interfaces */
+export class Interface<T = unknown> {
+    static _classInit: (cls: any) => any;
+    __name__: string;
+    _construct: (params: any, ...otherArgs: any[]) => any;
+    _init: (params: any) => void;
+    $gtype?: GType<T>;
+}
+
+/**
+ * Use this to signify a function that must be overridden in an
+ * implementation of the interface.
+ */
+export class NotImplementedError extends Error {
+    get name(): 'NotImplementedError'
+}
+
+// Expose GObject static properties for ES6 classes
+
+export const GTypeName: unique symbol;
+export const requires: unique symbol;
+export const interfaces: unique symbol;
+export const properties: unique symbol;
+export const signals: unique symbol;
+
+export let gtypeNameBasedOnJSPath: boolean;
+
+export let TYPE_BOOLEAN: GType<boolean>;
+export let Boolean: BooleanConstructor;
+
+export let TYPE_ENUM: GType<number>;
+export let TYPE_FLAGS: GType<number>;
+
+export let TYPE_DOUBLE: GType<number>;
+export let Double: NumberConstructor;
+
+export let TYPE_STRING: GType<string>;
+export let String: StringConstructor;
+
+export let TYPE_NONE: GType<undefined>;
+export let TYPE_POINTER: GType<undefined>;
+export let TYPE_BOXED: GType<unknown>;
+export let TYPE_PARAM: GType<unknown>;
+export let TYPE_INTERFACE: GType<unknown>;
+export let TYPE_OBJECT: GType<object>;
+export let TYPE_VARIANT: GType<GLib.Variant>;
+export let TYPE_INT: GType<number>;
+export let TYPE_UINT: GType<number>;
+export let TYPE_INT64: GType<number>;
+export let TYPE_UINT64: GType<number>;
+
+// fake enum for signal accumulators, keep in sync with gi/object.c
+export enum AccumulatorType {
+    NONE=0,
+    FIRST_WINS=1,
+    TRUE_HANDLED=2,
+}
+
+// A simple workaround if you have a class with .connect, .disconnect or .emit
+// methods (such as Gio.Socket.connect or NMClient.Device.disconnect)
+// The original g_signal_* functions are not introspectable anyway, because
+// we need our own handling of signal argument marshalling
+export function signal_connect(object: Object, name: string, handler: (...args: any[]) => any): number
+export function signal_connect_after(object: Object, name: string, handler: (...args: any[]) => any): number
+export function signal_emit_by_name(object: Object, ...nameAndArgs: any[]): void
+
+/**
+ * Finds the first signal handler that matches certain selection criteria.
+ * The criteria are passed as properties of a match object.
+ * The match object has to be non-empty for successful matches.
+ * If no handler was found, a falsy value is returned.
+ *
+ * @param instance the instance owning the signal handler to be found.
+ * @param match a properties object indicating whether to match by signal ID, detail, or callback function.
+ * @param match.signalId signal the handler has to be connected to.
+ * @param match.detail signal detail the handler has to be connected to.
+ * @param match.func the callback function the handler will invoke.
+ * @returns A valid non-0 signal handler ID for a successful match.
+ */
+export function signal_handler_find(instance: Object, match: {signalId: string, detail: string, func: (...args: any[]) => any}): number | bigint | object | null
+
+/**
+ * Blocks all handlers on an instance that match certain selection criteria.
+ * The criteria are passed as properties of a match object.
+ * The match object has to have at least `func` for successful matches.
+ * If no handlers were found, 0 is returned, the number of blocked handlers
+ * otherwise.
+ *
+ * @param instance the instance owning the signal handler to be found.
+ * @param match a properties object indicating whether to match by signal ID, detail, or callback function.
+ * @param match.signalId signal the handler has to be connected to.
+ * @param match.detail signal detail the handler has to be connected to.
+ * @param match.func the callback function the handler will invoke.
+ * @returns The number of handlers that matched.
+ */
+export function signal_handlers_block_matched(instance: Object, match: {signalId: string, detail: string, func: (...args: any[]) => any}): number
+
+/**
+ * Disconnects all handlers on an instance that match certain selection
+ * criteria.
+ * The criteria are passed as properties of a match object.
+ * The match object has to have at least `func` for successful matches.
+ * If no handlers were found, 0 is returned, the number of disconnected
+ * handlers otherwise.
+ *
+ * @param instance the instance owning the signal handler
+ *   to be found.
+ * @param match a properties object indicating whether to match by signal ID, detail, or callback function.
+ * @param match.signalId signal the handler has to be connected to.
+ * @param match.detail signal detail the handler has to be connected to.
+ * @param match.func the callback function the handler will invoke.
+ * @returns The number of handlers that matched.
+ */
+export function signal_handlers_unblock_matched(instance: Object, match: {signalId: string, detail: string, func: (...args: any[]) => any}): number
+
+/**
+ * Disconnects all handlers on an instance that match certain selection
+ * criteria.
+ * The criteria are passed as properties of a match object.
+ * The match object has to have at least `func` for successful matches.
+ * If no handlers were found, 0 is returned, the number of disconnected
+ * handlers otherwise.
+ *
+ * @param instance the instance owning the signal handler
+ *   to be found.
+ * @param match a properties object indicating whether to match by signal ID, detail, or callback function.
+ * @param match.signalId signal the handler has to be connected to.
+ * @param match.detail signal detail the handler has to be connected to.
+ * @param match.func the callback function the handler will invoke.
+ * @returns The number of handlers that matched.
+ */
+export function signal_handlers_disconnect_matched(instance: Object, match: {signalId: string, detail: string, func: (...args: any[]) => any}): number
+
+// Also match the macros used in C APIs, even though they're not introspected
+
+/**
+ * Blocks all handlers on an instance that match `func`.
+ *
+ * @param instance the instance to block handlers from.
+ * @param func the callback function the handler will invoke.
+ * @returns The number of handlers that matched.
+ */
+export function signal_handlers_block_by_func(instance: Object, func: (...args: any[]) => any): number;
+
+/**
+ * Unblocks all handlers on an instance that match `func`.
+ *
+ * @function
+ * @param instance the instance to unblock handlers from.
+ * @param func the callback function the handler will invoke.
+ * @returns The number of handlers that matched.
+ */
+export function signal_handlers_unblock_by_func(instance: Object, func: (...args: any[]) => any): number;
+
+/**
+ * Disconnects all handlers on an instance that match `func`.
+ *
+ * @param instance the instance to remove handlers from.
+ * @param func the callback function the handler will invoke.
+ * @returns The number of handlers that matched.
+ */
+export function signal_handlers_disconnect_by_func(instance: Object, func: (...args: any[]) => any): number;
+export function signal_handlers_disconnect_by_data(): void;
+
+export type Property<K extends ParamSpec> = K extends ParamSpecBoolean
+    ? boolean
+    : K extends ParamSpecDouble | ParamSpecInt | ParamSpecUInt | ParamSpecFloat | ParamSpecLong
+    ? number
+    : K extends ParamSpecInt64 | ParamSpecUInt64 | ParamSpecULong
+    ? number
+    : K extends ParamSpecFlags
+    ? number
+    : K extends ParamSpecString | ParamSpecUnichar
+    ? string
+    : K extends ParamSpecValueArray
+    ? any[]
+    : K extends ParamSpecObject // TODO?: <infer T>
+    ? ParamSpecObject // T
+    : K extends ParamSpecEnum // TODO?: <infer T><infer E>
+    ? ParamSpecEnum // E
+    : K extends ParamSpecBoxed // TODO?: <infer T><infer B>
+    ? ParamSpecBoxed //B
+    : K extends ParamSpecVariant
+    ? GLib.Variant
+    : any;
+
+// TODO: What about the generated class Closure 
+export type TClosure<R = any, P = any> = (...args: P[]) => R;
+
+// This should be replaces by a class of GObject.Object as soon as once we have implemented inheritance
+export class AnyClass {}
+
+export function registerClass<
+    T extends AnyClass,
+    Props extends { [key: string]: ParamSpec },
+    Interfaces extends { $gtype: GType }[],
+    Sigs extends {
+        [key: string]: {
+            param_types?: readonly GType[];
+            [key: string]: any;
+        };
+    }
+>(
+    options: MetaInfo<Props, Interfaces, Sigs>,
+    cls: T
+): T;
+
+export function registerClass<T extends AnyClass>(cls: T): T

package/templates/Gjs/Gio-2.0.d.ts

@@ -0,0 +1,64 @@
+// See https://gitlab.gnome.org/GNOME/gjs/-/blob/master/modules/core/overrides/Gio.js
+export const DBus: {
+    readonly session: DBusConnection;
+    readonly system: DBusConnection;
+    get(bus_type: BusType, cancellable?: Cancellable | null, callback?: AsyncReadyCallback | null): void;
+    get_finish(res: AsyncResult): DBusConnection;
+    get_sync(bus_type: BusType, cancellable?: Cancellable | null): DBusConnection;
+    own_name(
+        bus_type: BusType,
+        name: string,
+        flags: BusNameOwnerFlags,
+        bus_acquired_closure?: GObject.Closure | null,
+        name_acquired_closure?: GObject.Closure | null,
+        name_lost_closure?: GObject.Closure | null
+    ): number;
+    own_name_on_connection(
+        connection: DBusConnection,
+        name: string,
+        flags: BusNameOwnerFlags,
+        name_acquired_closure?: GObject.Closure | null,
+        name_lost_closure?: GObject.Closure | null
+    ): number;
+    unown_name(owner_id: number): void;
+    watch_name(
+        bus_type: BusType,
+        name: string,
+        flags: BusNameWatcherFlags,
+        name_appeared_closure?: GObject.Closure | null,
+        name_vanished_closure?: GObject.Closure | null
+    ): number;
+    unwatch_name(watcher_id: number): void;
+    watch_name_on_connection(
+        connection: DBusConnection,
+        name: string,
+        flags: BusNameWatcherFlags,
+        name_appeared_closure?: GObject.Closure | null,
+        name_vanished_closure?: GObject.Closure | null
+    ): number;
+}
+
+export module DBusExportedObject {
+    export interface ConstructorProperties {
+        [key: string]: any;
+    }
+}
+
+// See https://gitlab.gnome.org/GNOME/gjs/-/blob/master/modules/core/overrides/Gio.js
+export class DBusExportedObject {
+    static $gtype: GObject.GType<DBusExportedObject>;
+
+    constructor(properties?: Partial<DBusExportedObject.ConstructorProperties>, ...args: any[]);
+    _init(properties?: Partial<DBusExportedObject.ConstructorProperties>, ...args: any[]): void;
+
+    static wrapJSObject(info: string, obj: any): DBusExportedObject;
+    get_info(): DBusInterfaceInfo;
+    get_connection(): DBusConnection;
+    get_object_path(): string;
+    unexport_from_connection(connection: DBusConnection): void;
+    ["export"](busConnection: DBusConnection, objectPath: string): void;
+    unexport(): void;
+    flush(): void;
+    emit_signal(name: string, variant: GLib.Variant): void;
+    emit_property_changed(name: string, variant: GLib.Variant): void;
+}

package/templates/Gjs/Gjs.d.ts

@@ -0,0 +1,135 @@
+<% if(useNamespace){ %>
+import GObject from './GObject-2.0.js';
+import GLib from './GLib-2.0.js';
+<% } else { %>
+import * as GObject from './GObject-2.0.js';
+import * as GLib from './GLib-2.0.js';
+<% } %>
+
+// https://gitlab.gnome.org/GNOME/gjs/-/blob/1.72.0/modules/script/package.js
+export namespace Package {
+    /**
+     * Although there are references in the documentation of more properties that
+     * this object should accepts, only the following are actually used in the init code,
+     * and all the other have their values derived from them.
+     */
+    interface PackageInitParams {
+        name: string
+        version: string
+        prefix: string
+        libdir: string
+    }
+
+    export const name: string | undefined
+    export const version: string | undefined
+    export const prefix: string | undefined
+    export const datadir: string | undefined
+    export const libdir: string | undefined
+    export const pkgdatadir: string | undefined
+    export const pkglibdir: string | undefined
+    export const moduledir: string | undefined
+    export const localedir: string | undefined
+
+    export function init(params: PackageInitParams): void
+    export function run(module: { main: (argv: string[]) => void }): void
+    /** shortcut to init+run */
+    export function start(params: PackageInitParams): void
+    export function require(libs: Record<string, string>): void
+    export function requireSymbol(lib: string, ver: string, symbol: string): void
+    export function checkSymbol(lib: string, ver: string, symbol: string): void
+    export function initGettext(): void
+    /** @deprecated Use JS string interpolation */
+    export function initFormat(): void
+    export function initSubmodule(module: string): void
+}
+
+export namespace System {
+    export const programInvocationName: string
+    export const version: number
+    export const programPath: string | null
+    /** Equal to ARGV */
+    export const programArgs: string[]
+    export function exit(code: number): void
+    export function addressOfGObject(o: GObject.Object): object
+    export function addressOf(o: any): object
+    /** Runs the garbage collector */
+    export function gc(): void
+    export function refcount(o: GObject.Object): number
+    export function dumpHeap(path: string): void
+    export function dumpMemoryInfo(path: string): void
+}
+
+export namespace byteArray {
+    export function fromString(input: string): Uint8Array
+    export function fromGBytes(input: GLib.Bytes): Uint8Array
+    export function toString(x: Uint8Array): string
+    export function toGBytes(x: Uint8Array): GLib.Bytes
+}
+
+export namespace console {
+    export function interact(): void
+}
+
+export namespace Lang {
+    // TODO: There is a lot more in Lang
+    export function Class(props: any): void
+}
+
+export namespace gettext {
+    export enum LocaleCategory {
+        ALL,
+        COLLATE,
+        CTYPE,
+        MESSAGES,
+        MONETARY,
+        NUMERIC,
+        TIME,
+    }
+    export function setlocale(category: number, locale: string | null): string
+    export function textdomain(domainname: string | null): string
+    export function bindtextdomain(domainname: string, dirname: string | null): string
+    export function gettext(msgid: string): string
+    export function dgettext(domainname: string | null, msgid: string): string
+    export function dcgettext(domainname: string | null, msgid: string, category: number): string
+    export function ngettext(msgid: string, msgid_plural: string, n: number): string
+    export function dngettext(domainname: string, msgid: string, msgid_plural: string, n: number): string
+    export function domain(domainName: string): {
+        gettext: (msgid: string) => string
+        ngettext: (msgid: string, msgid_plural: string, n: number) => string
+        pgettext: (context: any, msgid: string) => any
+    }
+}
+
+export namespace Format {
+    export function vprintf(str: string, args: string[]): string
+    export function printf(fmt: string, ...args: any[]): void
+    // Following docs from gjs/modules/format.js
+    /**
+     * This function is intended to extend the String object and provide
+     * an String.format API for string formatting.
+     * It has to be set up using String.prototype.format = Format.format;
+     * Usage:
+     * "somestring %s %d".format('hello', 5);
+     * It supports %s, %d, %x and %f, for %f it also support precisions like
+     * "%.2f".format(1.526). All specifiers can be prefixed with a minimum
+     * field width, e.g. "%5s".format("foo"). Unless the width is prefixed
+     * with '0', the formatted string will be padded with spaces.
+     */
+    export function format(fmt: string, ...args: any[]): string
+}
+
+export namespace Mainloop {
+    export function quit(name: string): void
+    export function idle_source(handler: any, priority: number): any
+    export function idle_add(handler: any, priority: number): any
+    export function timeout_source(timeout: any, handler: any, priority: number): any
+    export function timeout_seconds_source(timeout: any, handler: any, priority: number): any
+    export function timeout_add(timeout: any, handler: any, priority: number): any
+    export function timeout_add_seconds(timeout: any, handler: any, priority: number): any
+    export function source_remove(id: any): any
+    export function run(name: string): void
+}
+
+export namespace Signals {
+    export function addSignalMethods(proto: object): void
+}

package/templates/Gjs/Gjs.js

@@ -0,0 +1,21 @@
+<% if(moduleType === 'esm') { %>
+  export const byteArray = imports.byteArray;
+  export const Lang = imports.lang;
+  export const Format = imports.format;
+  export const Mainloop = imports.mainloop;
+  export const gettext = imports.gettext;
+  export const System = imports.system;
+  export const Signals = imports.signals;
+  export const Package = imports.package;
+<% } else { %>  
+  module.exports = {
+    byteArray: imports.byteArray,
+    Lang: imports.lang,
+    Format: imports.format,
+    Mainloop: imports.mainloop,
+    gettext: imports.gettext,
+    System: imports.system,
+    Signals: imports.signals,
+    Package: imports.package
+  }
+<% } %>

package/templates/Gjs/cast.ts

@@ -0,0 +1,52 @@
+
+<% if(useNamespace){ %>
+    import GObject from './GObject-2.0.js';
+  <% } else { %>  
+    import * as GObject from './GObject-2.0.js';
+<% } %>
+
+const inheritanceTable: { [key: string]: string[] } = {
+<%_ for (const key of inheritanceTableKeys) { _%>
+    '<%= key %>': [
+    <%_ for (const value of inheritanceTable[key]) { _%>
+    '<%= value %>',
+    <%_ } _%>
+],
+<%_ } _%>
+}
+
+
+interface StaticNamedClass<T> {
+    new (...args: any[]): T
+    name: string
+}
+
+/**
+ * Casts between derived classes, performing a run-time type-check
+ * and raising an exception if the cast fails. Allows casting to implemented
+ * interfaces, too.
+ */
+export function giCast<T>(from_: GObject.Object, to_: StaticNamedClass<T>): T {
+    const desc: string = from_.toString()
+    let clsName: string|null = null
+    for (const k of desc.split(" ")) {
+        if (k.substring(0, 7) == "GIName:") {
+            clsName = k.substring(7)
+            break
+        }
+    }
+    const toName = to_.name.replace("_", ".")
+
+    if (toName === clsName)
+        return ((from_ as any) as T)
+
+    if (clsName) {
+        const parents = inheritanceTable[clsName]
+        if (parents) {
+            if (parents.indexOf(toName) >= 0)
+                return ((from_ as any) as T)
+        }
+    }
+
+    throw Error("Invalid cast of " + desc + "(" + clsName + ") to " + toName)
+}