@ts-for-gir/cli 4.0.0-beta.34 → 4.0.0-beta.36

package/README.md

@@ -125,7 +125,7 @@ Examples:
   ts-for-gir generate                       Run 'ts-for-gir generate' in your gjs
                                             project to generate typings for your
                                             project, pass the gir modules you need
-  ts-for-gir generate Gtk*                  You can also use wild cards
+  ts-for-gir generate 'Gtk*'                  You can also use wild cards
   ts-for-gir generate '*'                   If you want to parse all of your locally
                                             installed gir modules run
   ts-for-gir generate --configName='.ts-for-gir.gtk4.rc.js'  Use a special config file

package/bin/ts-for-gir

@@ -8502,10 +8502,17 @@ var DependencyManager = class _DependencyManager {
       await this.get("cairo", "1.0")
     ];
   }
-  createImportProperties(namespace, packageName, version) {
+  createImportProperties(namespace, packageName, version, libraryVersion) {
     const importPath = this.createImportPath(packageName, namespace, version);
     const importDef = this.createImportDef(namespace, importPath);
-    const packageJsonImport = this.createPackageJsonImport(importPath);
+    let effectiveLibraryVersion = libraryVersion;
+    if ((namespace === "GObject" || namespace === "Gio") && this._cache["GLib-2.0"]) {
+      const glibDep = this._cache["GLib-2.0"];
+      if (glibDep.libraryVersion.toString() !== "0.0.0") {
+        effectiveLibraryVersion = glibDep.libraryVersion;
+      }
+    }
+    const packageJsonImport = this.createPackageJsonImport(importPath, effectiveLibraryVersion);
     return {
       importPath,
       importDef,
@@ -8523,8 +8530,15 @@ var DependencyManager = class _DependencyManager {
   createImportDef(namespace, importPath) {
     return this.config.noNamespace ? `import type * as ${namespace} from '${importPath}'` : `import type ${namespace} from '${importPath}';`;
   }
-  createPackageJsonImport(importPath) {
-    const depVersion = this.config.workspace ? "workspace:^" : "*";
+  createPackageJsonImport(importPath, libraryVersion) {
+    let depVersion;
+    if (this.config.workspace) {
+      depVersion = "workspace:^";
+    } else if (libraryVersion) {
+      depVersion = `${libraryVersion.toString()}-${APP_VERSION}`;
+    } else {
+      depVersion = APP_VERSION;
+    }
     return `"${importPath}": "${depVersion}"`;
   }
   async parseGir(path) {
@@ -8604,7 +8618,7 @@ var DependencyManager = class _DependencyManager {
       version,
       libraryVersion,
       girXML,
-      ...this.createImportProperties(namespace, packageName, version)
+      ...this.createImportProperties(namespace, packageName, version, libraryVersion)
     };
     if (!noOverride && namespace === "cairo" && version === "1.0") {
       dependency.importDef = this.createImportDef("cairo", "cairo");
@@ -12723,15 +12737,27 @@ var GirModule = class _GirModule {
     const clazzes = Array.from(this.members.values()).filter(
       (m) => m instanceof IntrospectedBaseClass
     );
-    const res = clazzes.map((m) => [
+    for (const clazz of clazzes) {
+      if (name.startsWith(clazz.name)) {
+        const potentialCallbackName = name.slice(clazz.name.length);
+        const callback = clazz.callbacks.find((c) => c.name === potentialCallbackName);
+        if (callback) {
+          return [clazz.name, callback.name];
+        }
+      }
+    }
+    const allMatches = clazzes.map((m) => [
       m,
       m.callbacks.find((c) => c.name === name || c.resolve_names.includes(name))
-    ]).find((r) => r[1] != null);
-    if (res) {
-      return [res[0].name, res[1].name];
-    } else {
+    ]).filter((r) => r[1] != null);
+    if (allMatches.length === 0) {
       return [null, name];
     }
+    if (allMatches.length > 1) {
+      this.log.warn(`Found multiple matches for ${name}: ${allMatches.map((m) => m[0].name).join(", ")}`);
+    }
+    const res = allMatches[0];
+    return [res[0].name, res[1].name];
   }
   /**
    * This is an internal method to add TypeScript <reference>
@@ -16284,6 +16310,10 @@ function detectConflictType(ns, c, element, thisType) {
   if (fieldConflict) return fieldConflict;
   const propertyConflict = checkPropertyConflicts(ns, c, element, thisType);
   if (propertyConflict) return propertyConflict;
+  if (element instanceof IntrospectedVirtualClassFunction) {
+    const vfuncConflict = checkVfuncSignatureConflicts(ns, c, element, thisType);
+    if (vfuncConflict) return vfuncConflict;
+  }
   return checkFunctionNameConflicts(ns, c, element, thisType);
 }
 function checkFieldConflicts(c, element) {
@@ -16337,14 +16367,84 @@ function checkFunctionNameConflicts(ns, c, element, thisType) {
     })
   );
 }
+function checkVfuncSignatureConflicts(ns, c, element, thisType) {
+  if (!(c instanceof IntrospectedInterface)) {
+    return void 0;
+  }
+  return c.findParentMap((resolved_parent) => {
+    const parentVirtualMethods = resolved_parent.members.filter(
+      (m) => m instanceof IntrospectedVirtualClassFunction && m.name === element.name
+    );
+    for (const parentMethod of parentVirtualMethods) {
+      if (isConflictingFunction(ns, thisType, element, resolved_parent.getType(), parentMethod)) {
+        return 6 /* VFUNC_SIGNATURE_CONFLICT */;
+      }
+    }
+    if (resolved_parent instanceof IntrospectedInterface) {
+      const parentInterfaceVirtualMethods = resolved_parent.members.filter(
+        (m) => m instanceof IntrospectedVirtualClassFunction && m.name === element.name
+      );
+      for (const parentMethod of parentInterfaceVirtualMethods) {
+        if (isConflictingFunction(ns, thisType, element, resolved_parent.getType(), parentMethod)) {
+          return 6 /* VFUNC_SIGNATURE_CONFLICT */;
+        }
+      }
+    }
+    return void 0;
+  });
+}
 function createConflictElement(element, conflictType) {
   if (element instanceof IntrospectedField || element instanceof IntrospectedProperty) {
     return element.copy({
       type: new TypeConflict(element.type, conflictType)
     });
   }
+  if (conflictType === 6 /* VFUNC_SIGNATURE_CONFLICT */ && element instanceof IntrospectedVirtualClassFunction) {
+    return element;
+  }
   return null;
 }
+function hasVfuncSignatureConflicts(ns, interfaceClass) {
+  const thisType = interfaceClass.getType();
+  const virtualMethods = interfaceClass.members.filter(
+    (m) => m instanceof IntrospectedVirtualClassFunction
+  );
+  if (virtualMethods.length === 0) {
+    return false;
+  }
+  for (const vmethod of virtualMethods) {
+    const conflictType = checkVfuncSignatureConflicts(ns, interfaceClass, vmethod, thisType);
+    if (conflictType === 6 /* VFUNC_SIGNATURE_CONFLICT */) {
+      return true;
+    }
+  }
+  const hasParentWithVirtualMethods = interfaceClass.someParent((parent) => {
+    if (!(parent instanceof IntrospectedInterface)) {
+      return false;
+    }
+    const parentHasVirtualMethods = parent.members.some((m) => m instanceof IntrospectedVirtualClassFunction);
+    if (!parentHasVirtualMethods) {
+      return false;
+    }
+    for (const vmethod of virtualMethods) {
+      const parentVirtualMethods = parent.members.filter(
+        (m) => m instanceof IntrospectedVirtualClassFunction && m.name === vmethod.name
+      );
+      for (const parentMethod of parentVirtualMethods) {
+        const ourReturn = vmethod.return();
+        const parentReturn = parentMethod.return();
+        if (!ourReturn.equals(parentReturn)) {
+          return true;
+        }
+        if (isConflictingFunction(ns, thisType, vmethod, parent.getType(), parentMethod)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  });
+  return hasParentWithVirtualMethods;
+}
 
 // ../lib/src/utils/generation.ts
 function generateMemberName(tsVar) {
@@ -18326,7 +18426,8 @@ var ModuleGenerator = class _ModuleGenerator extends FormatGenerator {
     const isGObject = node.someParent((p) => p.namespace.namespace === "GObject" && p.name === "Object");
     const functions = filterFunctionConflict(node.namespace, node, node.members, []);
     const hasStaticFunctions = functions.some((f) => f instanceof IntrospectedStaticClassFunction);
-    const hasNamespace = isGObject || hasStaticFunctions || node.callbacks.length > 0;
+    const hasVirtualMethods = node.members.some((m) => m instanceof IntrospectedVirtualClassFunction);
+    const hasNamespace = isGObject || hasStaticFunctions || node.callbacks.length > 0 || hasVirtualMethods;
     return [
       ...this.generateClassNamespaces(node),
       ...hasNamespace ? this.generateInterfaceNamespace(node) : [],
@@ -19012,6 +19113,76 @@ constructor(properties?: Partial<${girClass.name}.ConstructorProps>, ...args: an
     );
     return def;
   }
+  /**
+   * Generate virtual methods with overloads for interfaces that have conflicting signatures.
+   * This is used when an interface can't inherit from Interface namespace due to signature conflicts.
+   * @param girInterface The interface to generate virtual methods for
+   * @param indentCount Indentation level
+   */
+  generateVirtualMethodOverloads(girInterface, indentCount = 1) {
+    const def = [];
+    const indent = generateIndent(indentCount);
+    const virtualMethods = girInterface.members.filter(
+      (m) => m instanceof IntrospectedVirtualClassFunction
+    );
+    if (virtualMethods.length === 0) {
+      return def;
+    }
+    def.push("");
+    def.push(`${indent}// Virtual methods - generated with overloads due to conflicts`);
+    def.push("");
+    const methodsByName = /* @__PURE__ */ new Map();
+    for (const vmethod of virtualMethods) {
+      const methods = methodsByName.get(vmethod.name) || [];
+      methods.push(vmethod);
+      methodsByName.set(vmethod.name, methods);
+    }
+    for (const [methodName, methods] of methodsByName) {
+      const parentMethods = [];
+      girInterface.someParent((parent) => {
+        const parentVirtualMethods = parent.members.filter(
+          (m) => m instanceof IntrospectedVirtualClassFunction && m.name === methodName
+        );
+        parentMethods.push(...parentVirtualMethods);
+        return false;
+      });
+      const allMethods = [...methods, ...parentMethods];
+      const uniqueSignatures = /* @__PURE__ */ new Map();
+      for (const method of allMethods) {
+        const signature = this.generateMethodSignature(method);
+        if (!uniqueSignatures.has(signature)) {
+          uniqueSignatures.set(signature, method);
+        }
+      }
+      for (const method of uniqueSignatures.values()) {
+        const methodDef = method.asString(this);
+        if (methodDef.length > 0 && !methodDef[0].includes("@ignore")) {
+          const docLines = [];
+          if (method.doc) {
+            docLines.push(...this.addGirDocComment(method.doc, [], indentCount));
+          }
+          if (docLines.length > 0) {
+            const lastLine = docLines[docLines.length - 1];
+            docLines[docLines.length - 1] = lastLine.replace(" */", ` * @ignore
+${indent} */`);
+          } else {
+            docLines.push(`${indent}/** @ignore */`);
+          }
+          def.push(...docLines);
+        }
+        def.push(...methodDef);
+      }
+    }
+    return def;
+  }
+  /**
+   * Generate a signature string for a virtual method (used for deduplication)
+   */
+  generateMethodSignature(method) {
+    const params = method.parameters.map((p) => `${p.name}:${p.type.print(this.namespace, this.config)}`).join(",");
+    const returnType = method.return().print(this.namespace, this.config);
+    return `${method.name}(${params}):${returnType}`;
+  }
   generateClassSignalInterfaces(girClass, indentCount = 0) {
     const def = [];
     const _tsSignals = girClass.signals;
@@ -19155,6 +19326,9 @@ constructor(properties?: Partial<${girClass.name}.ConstructorProps>, ...args: an
     if (girClass instanceof IntrospectedClass) {
       bodyDef.push(...this.generateClassSignalInterfaces(girClass, indentCount + 1));
     }
+    if (girClass instanceof IntrospectedInterface) {
+      bodyDef.push(...this.generateVirtualInterface(girClass, indentCount + 1));
+    }
     bodyDef.push(...this.generateClassCallbacks(girClass));
     bodyDef.push(...this.generateConstructPropsInterface(girClass, indentCount + 1));
     if (!bodyDef.length) {
@@ -19185,6 +19359,20 @@ constructor(properties?: Partial<${girClass.name}.ConstructorProps>, ...args: an
       ...superType ? [superType.node.getType().print(this.namespace, this.config)] : [],
       ..."implements" in resolution ? resolution.implements().map((i) => i.node.getType().print(this.namespace, this.config)) : []
     ];
+    let shouldGenerateVirtualMethodOverloads = false;
+    if (girClass instanceof IntrospectedInterface) {
+      const hasVirtualMethods = girClass.members.some((m) => m instanceof IntrospectedVirtualClassFunction);
+      if (hasVirtualMethods) {
+        const hasConflicts = hasVfuncSignatureConflicts(this.namespace, girClass);
+        if (hasConflicts) {
+          shouldGenerateVirtualMethodOverloads = true;
+        } else {
+          const typeNames = girClass.generics.map((g) => g.type.identifier).filter((name) => name && name.length > 0);
+          const genericTypeNames = typeNames.length > 0 ? `<${typeNames.join(", ")}>` : "";
+          implementationNames.push(`${girClass.name}.Interface${genericTypeNames}`);
+        }
+      }
+    }
     const ext = implementationNames.length ? ` extends ${implementationNames.join(", ")}` : "";
     const interfaceHead = `${girClass.name}${genericParameters}${ext}`;
     def.push(this.generateExport("interface", interfaceHead, "{"));
@@ -19196,11 +19384,68 @@ ${girClass.__ts__indexSignature}
     def.push(...this.generateClassProperties(girClass));
     def.push(...this.generateClassMemberFields(girClass));
     def.push(...this.generateClassMethods(girClass));
-    def.push(...this.generateClassVirtualMethods(girClass));
+    if (!(girClass instanceof IntrospectedInterface) || shouldGenerateVirtualMethodOverloads) {
+      if (shouldGenerateVirtualMethodOverloads && girClass instanceof IntrospectedInterface) {
+        def.push(...this.generateVirtualMethodOverloads(girClass));
+      } else {
+        def.push(...this.generateClassVirtualMethods(girClass));
+      }
+    }
     def.push("}");
     def.push("");
     return def;
   }
+  /**
+   * Generates a virtual-methods-only interface for proper GObject interface implementation.
+   * This interface contains only the virtual methods (vfunc_*) that need to be implemented
+   * when creating a class that implements a GObject interface.
+   */
+  generateVirtualInterface(girClass, indentCount = 1) {
+    const def = [];
+    if (!girClass) return def;
+    const indent = generateIndent(indentCount);
+    const virtualMethods = girClass.members.filter(
+      (m) => m instanceof IntrospectedVirtualClassFunction
+    );
+    if (virtualMethods.length === 0) {
+      return def;
+    }
+    const resolution = girClass.resolveParents();
+    const parentInterfaces = [];
+    const parentResolution = resolution.extends();
+    if (parentResolution && parentResolution.node instanceof IntrospectedInterface) {
+      const parentInterface = parentResolution.node;
+      const parentTypeIdentifier = parentResolution.identifier.resolveIdentifier(this.namespace, this.config)?.print(this.namespace, this.config);
+      const parentHasVirtualMethods = parentInterface.members.some(
+        (m) => m instanceof IntrospectedVirtualClassFunction
+      );
+      if (parentTypeIdentifier && parentHasVirtualMethods) {
+        parentInterfaces.push(`${parentTypeIdentifier}.Interface`);
+      }
+    }
+    let extendsClause = "";
+    if (parentInterfaces.length > 0) {
+      extendsClause = ` extends ${parentInterfaces.join(", ")}`;
+    }
+    const genericParameters = this.generateGenericParameters(girClass.generics);
+    def.push(`${indent}/**`);
+    def.push(`${indent} * Interface for implementing ${girClass.name}.`);
+    def.push(`${indent} * Contains only the virtual methods that need to be implemented.`);
+    def.push(`${indent} */`);
+    def.push(`${indent}interface Interface${genericParameters}${extendsClause} {`);
+    if (virtualMethods.length > 0) {
+      def.push(
+        ...this.generateFunctions(
+          filterFunctionConflict(girClass.namespace, girClass, virtualMethods, []),
+          indentCount + 1,
+          "Virtual methods"
+        )
+      );
+    }
+    def.push(`${indent}}`);
+    def.push("");
+    return def;
+  }
   extends(node) {
     const { namespace: ns, options: options2 } = this;
     if (node.superType) {
@@ -19851,7 +20096,7 @@ var examples4 = [
     `${APP_NAME} generate`,
     `Run '${APP_NAME} generate' in your gjs project to generate typings for your project, pass the gir modules you need for your project`
   ],
-  [`${APP_NAME} generate Gtk*`, "You can also use wild cards"],
+  [`${APP_NAME} generate 'Gtk*'`, "You can also use wild cards"],
   [`${APP_NAME} generate '*'`, "If you want to parse all of your locally installed gir modules run"],
   [`${APP_NAME} generate --configName='.ts-for-gir.gtk4.rc.js`, "Use a special config file"],
   [`${APP_NAME} generate --ignore=Gtk-4.0 xrandr-1.3`, "Generate .d.ts. files but not for Gtk-4.0 and xrandr-1.3"]
@@ -19912,7 +20157,7 @@ var description5 = "Generates JSON representation from GIR files for analysis an
 var logger7 = new Logger(true, "JsonCommand");
 var examples5 = [
   [`${APP_NAME} json`, `Run '${APP_NAME} json' in your gjs project to generate JSON files for your project`],
-  [`${APP_NAME} json Gtk*`, "You can also use wild cards"],
+  [`${APP_NAME} json 'Gtk*'`, "You can also use wild cards"],
   [`${APP_NAME} json '*'`, "If you want to parse all of your locally installed gir modules run"],
   [`${APP_NAME} json --configName='.ts-for-gir.gtk4.rc.js`, "Use a special config file"],
   [`${APP_NAME} json --ignore=Gtk-4.0 xrandr-1.3`, "Generate JSON files but not for Gtk-4.0 and xrandr-1.3"]

package/bin/ts-for-gir-dev

@@ -2,15 +2,15 @@
 
 /**
  * CLI Wrapper for TypeScript Execution
- * 
+ *
  * This wrapper is required to execute our CLI tool with the necessary Node.js parameters.
- * Due to "type": "module" specified in package.json, Node.js only accepts .js files 
+ * Due to "type": "module" specified in package.json, Node.js only accepts .js files
  * and rejects .ts or .sh files directly. This wrapper bridges that gap by:
- * 
+ *
  * 1. Providing a .js entry point that Node.js can execute
  * 2. Spawning the actual TypeScript file with experimental Node.js flags
  * 3. Enabling TypeScript execution without compilation step
- * 
+ *
  * The experimental flags used:
  * - --experimental-specifier-resolution=node: Enables Node.js-style module resolution
  * - --experimental-strip-types: Strips TypeScript types during execution
@@ -18,26 +18,26 @@
  * - --no-warnings: Suppresses experimental feature warnings
  */
 
-import { spawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { dirname, resolve } from 'node:path';
+import { spawn } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 
 // Get the current file's directory in ES module context
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 // Resolve the path to the actual TypeScript CLI entry point
-const tsPath = resolve(__dirname, '../src/start.ts');
+const tsPath = resolve(__dirname, "../src/start.ts");
 
 // Configure Node.js arguments for TypeScript execution
 const nodeArgs = [
-  '--experimental-specifier-resolution=node',
-  '--experimental-strip-types',
-  '--experimental-transform-types',
-  '--no-warnings',
-  tsPath,
-  ...process.argv.slice(2), // Forward all CLI arguments to the TypeScript file
+	"--experimental-specifier-resolution=node",
+	"--experimental-strip-types",
+	"--experimental-transform-types",
+	"--no-warnings",
+	tsPath,
+	...process.argv.slice(2), // Forward all CLI arguments to the TypeScript file
 ];
 
 // Spawn the Node.js process with TypeScript support and inherit stdio
-spawn('node', nodeArgs, { stdio: 'inherit' });
+spawn("node", nodeArgs, { stdio: "inherit" });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-for-gir/cli",
-  "version": "4.0.0-beta.34",
+  "version": "4.0.0-beta.36",
   "description": "TypeScript type definition generator for GObject introspection GIR files",
   "main": "src/index.ts",
   "module": "src/index.ts",
@@ -53,13 +53,13 @@
     ".": "./src/index.ts"
   },
   "devDependencies": {
-    "@gi.ts/parser": "^4.0.0-beta.34",
-    "@ts-for-gir/generator-base": "^4.0.0-beta.34",
-    "@ts-for-gir/generator-html-doc": "^4.0.0-beta.34",
-    "@ts-for-gir/generator-json": "^4.0.0-beta.34",
-    "@ts-for-gir/generator-typescript": "^4.0.0-beta.34",
-    "@ts-for-gir/lib": "^4.0.0-beta.34",
-    "@ts-for-gir/reporter": "^4.0.0-beta.34",
+    "@gi.ts/parser": "^4.0.0-beta.36",
+    "@ts-for-gir/generator-base": "^4.0.0-beta.36",
+    "@ts-for-gir/generator-html-doc": "^4.0.0-beta.36",
+    "@ts-for-gir/generator-json": "^4.0.0-beta.36",
+    "@ts-for-gir/generator-typescript": "^4.0.0-beta.36",
+    "@ts-for-gir/lib": "^4.0.0-beta.36",
+    "@ts-for-gir/reporter": "^4.0.0-beta.36",
     "@types/ejs": "^3.1.5",
     "@types/inquirer": "^9.0.9",
     "@types/node": "^24.2.1",
@@ -70,7 +70,7 @@
   },
   "dependencies": {
     "@inquirer/prompts": "^7.8.2",
-    "@ts-for-gir/templates": "^4.0.0-beta.34",
+    "@ts-for-gir/templates": "^4.0.0-beta.36",
     "colorette": "^2.0.20",
     "cosmiconfig": "^9.0.0",
     "ejs": "^3.1.10",

package/src/commands/generate.ts

@@ -32,7 +32,7 @@ const examples: ReadonlyArray<[string, string?]> = [
 		`${APP_NAME} generate`,
 		`Run '${APP_NAME} generate' in your gjs project to generate typings for your project, pass the gir modules you need for your project`,
 	],
-	[`${APP_NAME} generate Gtk*`, "You can also use wild cards"],
+	[`${APP_NAME} generate 'Gtk*'`, "You can also use wild cards"],
 	[`${APP_NAME} generate '*'`, "If you want to parse all of your locally installed gir modules run"],
 	[`${APP_NAME} generate --configName='.ts-for-gir.gtk4.rc.js`, "Use a special config file"],
 	[`${APP_NAME} generate --ignore=Gtk-4.0 xrandr-1.3`, "Generate .d.ts. files but not for Gtk-4.0 and xrandr-1.3"],

package/src/commands/json.ts

@@ -28,7 +28,7 @@ const logger = new Logger(true, "JsonCommand");
 
 const examples: ReadonlyArray<[string, string?]> = [
 	[`${APP_NAME} json`, `Run '${APP_NAME} json' in your gjs project to generate JSON files for your project`],
-	[`${APP_NAME} json Gtk*`, "You can also use wild cards"],
+	[`${APP_NAME} json 'Gtk*'`, "You can also use wild cards"],
 	[`${APP_NAME} json '*'`, "If you want to parse all of your locally installed gir modules run"],
 	[`${APP_NAME} json --configName='.ts-for-gir.gtk4.rc.js`, "Use a special config file"],
 	[`${APP_NAME} json --ignore=Gtk-4.0 xrandr-1.3`, "Generate JSON files but not for Gtk-4.0 and xrandr-1.3"],

package/src/module-loader.ts

@@ -235,6 +235,8 @@ export class ModuleLoader {
 		const GObject = await this.dependencyManager.get("GObject", "2.0");
 		const Cairo = await this.dependencyManager.get("cairo", "1.0");
 
+		// Update library versions for GObject and Gio to use GLib's version
+
 		const dependencies = await this.fileFinder.girFilePathToDependencies(girFiles);
 
 		const { loaded, failed } = await this.loadGirModules(