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

package/bin/ts-for-gir

@@ -12723,15 +12723,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 +16296,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 +16353,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 +18412,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 +19099,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 +19312,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 +19345,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 +19370,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) {

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.35",
   "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.35",
+    "@ts-for-gir/generator-base": "^4.0.0-beta.35",
+    "@ts-for-gir/generator-html-doc": "^4.0.0-beta.35",
+    "@ts-for-gir/generator-json": "^4.0.0-beta.35",
+    "@ts-for-gir/generator-typescript": "^4.0.0-beta.35",
+    "@ts-for-gir/lib": "^4.0.0-beta.35",
+    "@ts-for-gir/reporter": "^4.0.0-beta.35",
     "@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.35",
     "colorette": "^2.0.20",
     "cosmiconfig": "^9.0.0",
     "ejs": "^3.1.10",