@ts-for-gir/lib 3.0.0-beta.11

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

@@ -0,0 +1,101 @@
+// 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;
+}
+
+/**
+ * A convenient helper to create Promise wrappers for asynchronous functions in GJS.
+ * 
+ * This utility replaces the original function on the class prototype with a Promise-based version,
+ * allowing the function to be called on any instance of the class, including subclasses.
+ * Simply pass the class prototype, the "async" function name, and the "finish" function name as arguments.
+ * 
+ * The function can be used like any other Promise, without the need for a custom wrapper, by leaving out the callback argument.
+ * The original function will still be available, and can be used by passing the callback.
+ * 
+ * @param proto - The class prototype that contains the asynchronous function.
+ * @param asyncFunc - The name of the asynchronous function.
+ * @param finishFunc - The name of the "finish" function that is used to retrieve the result of the asynchronous function.
+ * 
+ * @version Gjs 1.54
+ * @see https://gjs.guide/guides/gjs/asynchronous-programming.html#promisify-helper
+ * 
+ * @example
+ * ```js
+ * import Gio from "gi://Gio";
+ * 
+ * Gio._promisify(Gio.InputStream.prototype, 'read_bytes_async', 'read_bytes_finish');
+ * 
+ * try {
+ *    const inputStream = new Gio.UnixInputStream({fd: 0});
+ *    const bytes = await inputStream.read_bytes_async(4096, GLib.PRIORITY_DEFAULT, null);
+ * } catch (e) {
+ *    logError(e, 'Failed to read bytes');
+ * }
+ * ```
+ * 
+ */
+export function _promisify(proto: any, asyncFunc: string, finishFunc?: string): void;
+
+/** Temporary Gio.File.prototype fix */
+export const _LocalFilePrototype: typeof File.prototype;

package/templates/Gjs/Gjs.d.ts

@@ -0,0 +1,204 @@
+<% const gobject = dep.find('GObject') %>
+<% const glib = dep.find('GLib') %>
+
+<%_ if(noNamespace){ _%>
+    import type * as GObject from './<%= gobject.packageName %>.js';
+    import type * as GLib from './<%= glib.packageName %>.js';
+<%_ } else { _%>
+    import type GObject from './<%= gobject.packageName %>.js';
+    import type GLib from './<%= glib.packageName %>.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 pgettext(context: string, msgid: string): string
+    export function dpgettext(dom: string | null, context: string, msgid: string): string
+    export function domain(domainName: string): {
+        gettext: (msgid: string) => string
+        ngettext: (msgid: string, msgid_plural: string, n: number) => string
+        pgettext: (context: string, msgid: string) => string
+    }
+}
+
+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 {
+
+    /**
+     * You can use the `Signals.addSignalMethods` method to apply the `Signals` convenience methods to an `Object`.
+     * Generally, this is called on an object prototype, but may also be called on an object instance.
+     * You can use this Interface for this object or prototype to make the methods in typescript known
+     * @example
+     * ```ts
+     * const Signals = imports.signals;
+     * 
+     * // Define an interface with the same name of your class to make the methods known
+     * interface Events extends Signals.Methods {}
+     * 
+     * class Events {}
+     * Signals.addSignalMethods(Events.prototype);
+     * 
+     * const events = new Events();
+     * 
+     * // Typescript will not complain here
+     * events.emit("test-signal", "test argument");
+     * ```
+     */
+    export interface Methods {
+        /**
+         * Connects a callback to a signal for an object. Pass the returned ID to
+         * `disconect()` to remove the handler.
+         * 
+         * If `callback` returns `true`, emission will stop and no other handlers will be
+         * invoked.
+         * 
+         * > Warning: Unlike GObject signals, `this` within a signal callback will always
+         * > refer to the global object (ie. `globalThis`).
+         * 
+         * @param sigName A signal name
+         * @param callback A callback function
+         * @returns A handler ID
+         */
+        connect(sigName: string, callback: (self: any, ...args: any[]) => void): number;
+        /**
+         * Emits a signal for an object. Emission stops if a signal handler returns `true`.
+         * 
+         * Unlike GObject signals, it is not necessary to declare signals or define their
+         * signature. Simply call `emit()` with whatever signal name you wish, with
+         * whatever arguments you wish.
+         * @param sigName A signal name
+         * @param args Any number of arguments, of any type
+         */
+        emit(sigName: string, ...args: any[]): void;
+        /**
+         * Disconnects a handler for a signal.
+         * @param id The ID of the handler to be disconnected
+         */
+        disconnect(id: number): void;
+        /**
+         * Disconnects all signal handlers for an object.
+         */
+        disconnectAll(): void
+        /**
+         * Checks if a handler ID is connected.
+         * @param id The ID of the handler to be disconnected
+         * @returns `true` if connected, or `false` if not
+         */
+        signalHandlerIsConnected(id: number): boolean;
+    }
+
+    export function addSignalMethods<T = any>(proto: T): proto is T & Methods;
+}

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/GnomeShell.d.ts

@@ -0,0 +1,154 @@
+import type * as DbusUtils from './misc/dbusUtils.js';
+import type * as ExtensionUtils from './misc/extensionUtils.js';
+import type * as FileUtils from './misc/fileUtils.js';
+import type * as GnomeSession from './misc/gnomeSession.js';
+import type * as ParentalControlsManager from './misc/parentalControlsManager.js';
+import type * as Signals from './misc/signals.js';
+
+// TODO: https://gitlab.gnome.org/GNOME/gnome-shell/-/tree/main/js/misc
+export namespace misc {
+    export const dbusUtils: typeof DbusUtils;
+    export const extensionUtils: typeof ExtensionUtils;
+    export const fileUtils: typeof FileUtils;
+    export const gnomeSession: typeof GnomeSession;
+    export const history: any;
+    export const ibusManager: any;
+    export const inputMethod: any;
+    export const introspect: any;
+    export const jsParse: any;
+    export const keyboardManager: any;
+    export const loginManager: any;
+    export const modemManager: any;
+    export const objectManager: any;
+    export const params: any;
+    export const parentalControlsManager: typeof ParentalControlsManager;
+    export const permissionStore: any;
+    export const signalTracker: any;
+    export const signals: typeof Signals;
+    export const smartcardManager: any;
+    export const systemActions: any;
+    export const util: any;
+    export const weather: any;
+}
+import type * as Components from './ui/components/index.js';
+import type * as AccessDialog from './ui/accessDialog.js';
+import type * as AltTab from './ui/altTab.js';
+import type * as Animation from './ui/animation.js';
+import type * as AppDisplay from './ui/appDisplay.js';
+import type * as AppFavorites from './ui/appFavorites.js';
+import type * as AppMenu from './ui/appMenu.js';
+import type * as AudioDeviceSelection from './ui/audioDeviceSelection.js';
+import type * as Background from './ui/background.js';
+import type * as BackgroundMenu from './ui/backgroundMenu.js';
+import type * as BarLevel from './ui/barLevel.js';
+import type * as Boxpointer from './ui/boxpointer.js';
+import type * as Calendar from './ui/calendar.js';
+import type * as CheckBox from './ui/checkBox.js';
+import type * as CloseDialog from './ui/closeDialog.js';
+import type * as Dialog from './ui/dialog.js';
+import type * as DnD from './ui/dnd.js';
+import type * as IconGrid from './ui/iconGrid.js';
+import type * as Layout from './ui/layout.js';
+import type * as Main from './ui/main.js';
+import type * as MessageList from './ui/messageList.js';
+import type * as MessageTray from './ui/messageTray.js';
+import type * as ModalDialog from './ui/modalDialog.js';
+import type * as Mpris from './ui/mpris.js';
+import type * as NotificationDaemon from './ui/notificationDaemon.js';
+import type * as Panel from './ui/panel.js';
+import type * as PanelMenu from './ui/panelMenu.js';
+import type * as PopupMenu from './ui/popupMenu.js';
+import type * as Ripples from './ui/ripples.js';
+import type * as Search from './ui/search.js';
+import type * as SwitcherPopup from './ui/switcherPopup.js';
+import type * as UserWidget from './ui/userWidget.js';
+
+// TODO: https://gitlab.gnome.org/GNOME/gnome-shell/-/tree/main/js/ui
+export namespace ui {
+    export const components: typeof Components;
+    export const status: any;
+    export const accessDialog: typeof AccessDialog;
+    export const altTab: typeof AltTab;
+    export const animation: typeof Animation;
+    export const appDisplay: typeof AppDisplay;
+    export const appFavorites: typeof AppFavorites;
+    export const appMenu: typeof AppMenu;
+    export const audioDeviceSelection: typeof AudioDeviceSelection;
+    export const background: typeof Background;
+    export const backgroundMenu: typeof BackgroundMenu;
+    export const barLevel: typeof BarLevel;
+    export const boxpointer: typeof Boxpointer;
+    export const calendar: typeof Calendar;
+    export const checkBox: typeof CheckBox;
+    export const closeDialog: typeof CloseDialog;
+    export const ctrlAltTab: any;
+    export const dash: any;
+    export const dateMenu: any;
+    export const dialog: typeof Dialog;
+    export const dnd: typeof DnD;
+    export const edgeDragAction: any;
+    export const endSessionDialog: any;
+    export const environment: any;
+    export const extensionDownloader: any;
+    export const extensionSystem: any;
+    export const focusCaretTracker: any;
+    export const grabHelper: any;
+    export const ibusCandidatePopup: any;
+    export const iconGrid: typeof IconGrid;
+    export const inhibitShortcutsDialog: any;
+    export const init: any;
+    export const kbdA11yDialog: any;
+    export const keyboard: any;
+    export const layout: typeof Layout;
+    export const lightbox: any;
+    export const locatePointer: any;
+    export const lookingGlass: any;
+    export const magnifier: any;
+    export const main: typeof Main;
+    export const messageList: typeof MessageList;
+    export const messageTray: typeof MessageTray;
+    export const modalDialog: typeof ModalDialog;
+    export const mpris: typeof Mpris;
+    export const notificationDaemon: typeof NotificationDaemon;
+    export const osdMonitorLabeler: any;
+    export const osdWindow: any;
+    export const overview: any;
+    export const overviewControls: any;
+    export const padOsd: any;
+    export const pageIndicators: any;
+    export const panel: typeof Panel;
+    export const panelMenu: typeof PanelMenu;
+    export const pointerA11yTimeout: any;
+    export const pointerWatcher: any;
+    export const popupMenu: typeof PopupMenu;
+    export const quickSettings: any;
+    export const remoteSearch: any;
+    export const ripples: typeof Ripples;
+    export const runDialog: any;
+    export const screenShield: any;
+    export const screenshot: any;
+    export const scripting: any;
+    export const search: typeof Search;
+    export const searchController: any;
+    export const sessionMode: any;
+    export const shellDBus: any;
+    export const shellEntry: any;
+    export const shellMountOperation: any;
+    export const slider: any;
+    export const swipeTracker: any;
+    export const switchMonitor: any;
+    export const switcherPopup: typeof SwitcherPopup;
+    export const unlockDialog: any;
+    export const userWidget: typeof UserWidget;
+    export const welcomeDialog: any;
+    export const windowAttentionHandler: any;
+    export const windowManager: any;
+    export const windowMenu: any;
+    export const windowPreview: any;
+    export const workspace: any;
+    export const workspaceAnimation: any;
+    export const workspaceSwitcherPopup: any;
+    export const workspaceThumbnail: any;
+    export const workspacesView: any;
+    export const xdndHandler: any;
+}

package/templates/Gjs/GnomeShell.js

@@ -0,0 +1,10 @@
+<% if(moduleType === 'esm') { %>
+    export const misc = imports.misc;
+    export const ui = imports.ui;
+  <% } else { %>  
+    module.exports = {
+      misc: imports.misc,
+      ui: imports.ui
+    }
+  <% } %>
+