Feature: Add method handling to mixin processing in KDL

inputfiles/addedTypes.jsonc

@@ -1,28 +1,4 @@
 {
-    "mixins": {
-        "mixin": {
-            "DocumentOrShadowRoot": {
-                // Manually moved from Document
-                // See https://github.com/w3c/csswg-drafts/issues/5886 and https://github.com/w3c/csswg-drafts/issues/556
-                "methods": {
-                    "method": {
-                        "elementFromPoint": {
-                            "name": "elementFromPoint",
-                            "overrideSignatures": [
-                                "elementFromPoint(x: number, y: number): Element | null"
-                            ]
-                        },
-                        "elementsFromPoint": {
-                            "name": "elementsFromPoint",
-                            "overrideSignatures": [
-                                "elementsFromPoint(x: number, y: number): Element[]"
-                            ]
-                        }
-                    }
-                }
-            }
-        }
-    },
     "callbackInterfaces": {
         "interface": {}
     },

inputfiles/patches/cssom-view.kd

@@ -0,0 +1,12 @@
+// Manually moved from Document
+// See https://github.com/w3c/csswg-drafts/issues/5886 and https://github.com/w3c/csswg-drafts/issues/556
+interface-mixin DocumentOrShadowRoot {
+    method elementFromPoint returns=Element nullable=#true {
+        param x type=long
+        param y type=long
+    }
+    method elementsFromPoint returns="Element" array {
+        param x type=long
+        param y type=long
+    }
+}

src/build/patches.ts

@@ -1,5 +1,5 @@
 import { parse, type Node } from "kdljs";
-import type { Enum, Event, Property, Interface, WebIdl } from "./types";
+import type { Enum, Event, Property, Interface, WebIdl, Method } from "./types";
 import { readdir, readFile } from "fs/promises";
 import { merge } from "./helpers.js";
 
@@ -76,6 +76,7 @@ function handleMixin(node: Node): DeepPartial<Interface> {
 
   const event: Event[] = [];
   const property: Record<string, Partial<Property>> = {};
+  const method: Record<string, Partial<Method>> = {};
 
   for (const child of node.children) {
     switch (child.name) {
@@ -87,6 +88,11 @@ function handleMixin(node: Node): DeepPartial<Interface> {
         property[propName] = handleProperty(child);
         break;
       }
+      case "method": {
+        const methodName = child.values[0] as string;
+        method[methodName] = handleMethod(child);
+        break;
+      }
       default:
         throw new Error(`Unknown node name: ${child.name}`);
     }
@@ -96,6 +102,7 @@ function handleMixin(node: Node): DeepPartial<Interface> {
     name,
     events: { event },
     properties: { property },
+    methods: { method },
   } as DeepPartial<Interface>;
   if (node.properties.extends) {
     result.extends = node.properties.extends as string;
@@ -125,6 +132,32 @@ function handleProperty(child: Node): Partial<Property> {
   };
 }
 
+/**
+ * Handles a child node of type "method" and adds it to the method object.
+ * @param child The child node to handle.
+ */
+function handleMethod(child: Node): Partial<Method> {
+  const name = child.values[0] as string;
+  const isArray = child.values[1] as boolean | undefined;
+  const returnType = child.properties.returns as string;
+  const nullable = child.properties.nullable as boolean;
+
+  const params = child.children.map((c) => ({
+    name: c.values[0] as string,
+    type: c.properties.type as string,
+  }));
+
+  const signature: Method["signature"] = [
+    {
+      type: isArray ? "sequence" : returnType,
+      param: params,
+      nullable,
+      ...(isArray ? { subtype: { type: returnType } } : {}),
+    },
+  ];
+  return { name, signature };
+}
+
 /**
  * Collect all file URLs in a directory.
  */