Link to known types

docs/.vitepress/theme/Signature.vue

@@ -1,12 +1,16 @@
 <script setup lang="ts">
-  const props = defineProps(["name", "typeParams", "args", "returnType"]);
+
+  import TypeRef from './TypeRef.vue';
+  const props = defineProps<{name: string, returnType: any}>();
+
 </script>
 
 <template>
   <span>
     <slot name="pre"></slot>
     <span class="code">
-      <strong class="name">{{ name }}</strong>: <span class="type">{{ returnType }}</span>
+      <strong class="name">{{ name }}</strong>:
+      <span class="type" v-if="returnType"><TypeRef :type="returnType" /></span>
       <slot></slot>
     </span>
     <slot name="post"></slot>

docs/.vitepress/theme/TypeRef.vue

@@ -0,0 +1,33 @@
+<script setup lang="ts">
+
+  import { withBase } from 'vitepress';
+
+  interface Path {
+    pack: string[];
+    module: string;
+    name: string;
+  }
+
+  interface RuntimeType {
+    path: Path;
+    typeParams: RuntimeType[];
+  }
+
+  const props = defineProps<{type: RuntimeType}>();
+
+</script>
+
+<template>
+  <span>
+    <template v-if="type.path.pack[0] == 'minetest'">
+      <a :href="withBase(['reference', ...type.path.pack, type.path.name]
+        .reduce((curr, next) => `${curr}/${next}`, '') + '.html')">
+        {{type.path.name}}
+      </a>
+    </template>
+    <template v-else>{{type.path.name}}</template>
+    <template v-if="type.typeParams.length > 0">&lt;<span v-for="(param, index) in type.typeParams" :key="index">
+      <TypeRef :type="param" /><span v-if="index !== type.typeParams.length - 1">, </span>
+    </span>&gt;</template>
+  </span>
+</template>

scripts/generate-class-reference.ts

@@ -4,7 +4,7 @@ import { abort, assertHaxeExists, decodeUtf8, encodeUtf8, invokeHaxe, mustArray,
 import { path, xml } from "./deps.ts";
 import { Context } from "./haxe/documentation/context.ts";
 import { renderType } from "./haxe/documentation/render.ts";
-import { Class, Interface, Method, Path, Property, Type } from "./haxe/types.ts";
+import { Class, GenericRuntimeType, Interface, Method, Path, Property, Type } from "./haxe/types.ts";
 
 await assertHaxeExists();
 
@@ -89,11 +89,21 @@ for (const typeNode of document["~children"] as XmlNode[]) {
         const method = new Method(memberName);
         member = method;
       } else {
-        const property = new Property(memberName);
-        const typeNode = (memberNode["~children"] as XmlNode[]).find(child => child["~name"].length == 1);
-        if (typeNode && typeNode["@path"]) {
-          property.type = Path.fromDotPath(typeNode["@path"]! as string);
+
+        function selectTypeNodes(node: XmlNode): XmlNode[] {
+          return (node["~children"] as XmlNode[]).filter(child => child["~name"].length == 1);
+        }
+
+        function buildType(node: XmlNode): GenericRuntimeType {
+          const path = Path.fromDotPath(node["@path"] as string || "Dynamic");
+          const type = new GenericRuntimeType(path, []);
+          for (const childNode of selectTypeNodes(node)) {
+            type.typeParams.push(buildType(childNode));
+          }
+          return type;
         }
+
+        const property = new Property(memberName, buildType(selectTypeNodes(memberNode).at(0)!));
         member = property;
       }
     }

scripts/haxe/documentation/render.ts

@@ -106,7 +106,7 @@ function renderInterfaceTypeInfo(ctx: Context, iface: Interface): string {
 }
 
 function renderPropertySignature(property: Property): string {
-  let markdown = `<Signature name="${property.name}" returnType="${property.type}">`;
+  let markdown = `<Signature name="${property.name}" :returnType='${JSON.stringify(property.type)}'>`;
   markdown += "</Signature>";
   return markdown;
 }

scripts/haxe/types.ts

@@ -72,6 +72,16 @@ export class Path {
   }
 }
 
+export class RuntimeType {
+  constructor() { }
+}
+
+export class GenericRuntimeType extends RuntimeType {
+  constructor(public path: Path, public typeParams: RuntimeType[]) {
+    super();
+  }
+}
+
 export interface Documentible {
   documentation?: string;
 }
@@ -167,9 +177,10 @@ export abstract class Member implements Documentible {
 }
 
 export class Property extends Member {
-  type?: Path;
-  constructor(name: string) {
+  type: RuntimeType;
+  constructor(name: string, type: RuntimeType) {
     super(name);
+    this.type = type;
   }
 }