fix: add new proto/enums support

Author: qubka

components/content/Parameter.vue

@@ -1,21 +1,26 @@
 <script setup lang="ts">
 import {CardContent} from '@/components/ui/card';
 import type {ParamType} from '~/lib/manifest';
+import {definitionOf} from '~/lib/manifest';
 const props = defineProps<{
   group: string | undefined;
   param: ParamType | undefined;
 }>()
+// A prototype/enum may be written as a name; resolveManifest has replaced those
+// with the definition, so anything still a string names nothing and is skipped.
+const prototype = computed(() => definitionOf(props.param?.prototype));
+const enumerator = computed(() => definitionOf(props.param?.enum));
 </script>
 
 <template>
-  <span v-if="param?.prototype">
-    <a :href="`#/${group}/${param.prototype?.name}`" class="text-primary hover:underline" >
-      {{ param.prototype?.name }}
+  <span v-if="prototype">
+    <a :href="`#/${group}/${prototype.name}`" class="text-primary hover:underline" >
+      {{ prototype.name }}
     </a>
   </span>
-  <span v-else-if="param?.enum">
-    <a :href="`#/${group}/${param.enum?.name}`" class="text-primary hover:underline" >
-      {{ param.enum?.name }}
+  <span v-else-if="enumerator">
+    <a :href="`#/${group}/${enumerator.name}`" class="text-primary hover:underline" >
+      {{ enumerator.name }}
     </a>
   </span>
   <span v-else class="text-primary">

components/content/Signature.vue

@@ -1,20 +1,25 @@
 <script setup lang="ts">
 import type {ParamType} from '~/lib/manifest';
+import {definitionOf} from '~/lib/manifest';
 const props = defineProps<{
   group: string | undefined;
   param: ParamType | undefined;
 }>()
+// A prototype/enum may be written as a name; resolveManifest has replaced those
+// with the definition, so anything still a string names nothing and is skipped.
+const prototype = computed(() => definitionOf(props.param?.prototype));
+const enumerator = computed(() => definitionOf(props.param?.enum));
 </script>
 
 <template>
-  <span v-if="param?.prototype">
-    <a :href="`#/${group}/${param.prototype?.name}`" class="text-primary hover:underline" >
-      {{ param.prototype?.name }}
+  <span v-if="prototype">
+    <a :href="`#/${group}/${prototype.name}`" class="text-primary hover:underline" >
+      {{ prototype.name }}
     </a>
   </span>
-  <span v-else-if="param?.enum">
-    <a :href="`#/${group}/${param.enum?.name}`" class="text-primary hover:underline" >
-      {{ param.enum?.name }}
+  <span v-else-if="enumerator">
+    <a :href="`#/${group}/${enumerator.name}`" class="text-primary hover:underline" >
+      {{ enumerator.name }}
     </a>
   </span>
   <span v-else class="text-primary">

lib/docStore.ts

@@ -12,6 +12,7 @@ import type {
 
     ClassType,
 } from '~/lib/manifest';
+import { definitionOf, resolveManifest } from '~/lib/manifest';
 
 // Add new constants for cache expiration (in milliseconds) and database version
 const CACHE_EXPIRATION_TIME = 24 * 60 * 60 * 1000; // 24 hours for example
@@ -30,14 +31,17 @@ function ProcessItem(
     delgs: MethodMap,
     enums: EnumMap
 ): void {
-    if (param.prototype && param.prototype.name) {
-        if (!delgs[param.prototype.name]) {
-            delgs[param.prototype.name] = param.prototype;
+    const prototype = definitionOf(param.prototype);
+    const enumerator = definitionOf(param.enum);
+
+    if (prototype && prototype.name) {
+        if (!delgs[prototype.name]) {
+            delgs[prototype.name] = prototype;
+            ProcessMethod(prototype, delgs, enums);
         }
-        ProcessMethod(param.prototype, delgs, enums);
-    } else if (param.enum && param.enum.name) {
-        if (!enums[param.enum.name] && param.enum.values) {
-            enums[param.enum.name] = param.enum;
+    } else if (enumerator && enumerator.name) {
+        if (!enums[enumerator.name] && enumerator.values) {
+            enums[enumerator.name] = enumerator;
         }
     }
 }
@@ -182,7 +186,9 @@ export const useDocStore = defineStore('docStore', {
         async refreshDocInBackground(url: string) {
             try {
                 const response: Response = await fetch(url);
-                const manifest: ManifestType = await response.json();
+                // Link by-name prototype/enum references before anything reads the
+                // manifest, so the rest of this store only ever sees definitions.
+                const manifest: ManifestType = resolveManifest(await response.json());
 
                 let data: Document = {};
 

lib/manifest.ts

@@ -3,6 +3,8 @@ export type ManifestType = {
     name?: string;
     methods?: MethodType[];
     classes?: ClassType[];
+    prototypes?: MethodType[];
+    enums?: EnumType[];
 }
 
 export type BaseType = {
@@ -29,8 +31,8 @@ export type MethodType = BaseType & {
 export type ParamType = BaseType & {
     type?: string;
     ref?: boolean;
-    prototype?: MethodType;
-    enum?: EnumType;
+    prototype?: MethodType | string;
+    enum?: EnumType | string;
 };
 
 export type AliasType = BaseType & {
@@ -56,3 +58,79 @@ export type MethodMap = Record<string, MethodType>;
 export type EnumMap = Record<string, EnumType>;
 export type ClassMap = Record<string, ClassType>;
 
+/**
+ * Links every by-name prototype/enum reference in a manifest to its definition,
+ * and hoists inline definitions into the shared tables, so that afterwards every
+ * `paramTypes`/`retType` entry carries a full object.
+ *
+ * Mirrors Manifest::Resolve in plugify core. Unlike the loader this is forgiving:
+ * a reference that names nothing is left as it was rather than rejected, since a
+ * viewer showing most of a page beats one showing an error.
+ */
+export function resolveManifest(manifest: ManifestType): ManifestType {
+    const prototypes: MethodMap = {};
+    const enums: EnumMap = {};
+
+    for (const prototype of manifest.prototypes ?? []) {
+        if (prototype.name) prototypes[prototype.name] = prototype;
+    }
+    for (const enumerator of manifest.enums ?? []) {
+        if (enumerator.name) enums[enumerator.name] = enumerator;
+    }
+
+    // Pass one: collect the definitions written inline.
+    const collect = (param: ParamType, seen: Set<MethodType>) => {
+        const prototype = param.prototype;
+        if (prototype && typeof prototype !== 'string' && prototype.name) {
+            prototypes[prototype.name] ??= prototype;
+            if (!seen.has(prototype)) {
+                seen.add(prototype);
+                for (const nested of prototype.paramTypes ?? []) collect(nested, seen);
+                if (prototype.retType) collect(prototype.retType, seen);
+            }
+        }
+        const enumerator = param.enum;
+        if (enumerator && typeof enumerator !== 'string' && enumerator.name && enumerator.values?.length) {
+            enums[enumerator.name] ??= enumerator;
+        }
+    };
+
+    const seen = new Set<MethodType>();
+    for (const method of manifest.methods ?? []) {
+        for (const param of method.paramTypes ?? []) collect(param, seen);
+        if (method.retType) collect(method.retType, seen);
+    }
+    for (const prototype of manifest.prototypes ?? []) {
+        for (const param of prototype.paramTypes ?? []) collect(param, seen);
+        if (prototype.retType) collect(prototype.retType, seen);
+    }
+
+    // Pass two: swap each reference for the definition it names. Every definition
+    // is known by now, so references may point forwards.
+    const link = (param: ParamType) => {
+        if (typeof param.prototype === 'string') {
+            param.prototype = prototypes[param.prototype] ?? param.prototype;
+        }
+        if (typeof param.enum === 'string') {
+            param.enum = enums[param.enum] ?? param.enum;
+        }
+    };
+
+    const linkOwner = (owner: MethodType) => {
+        for (const param of owner.paramTypes ?? []) link(param);
+        if (owner.retType) link(owner.retType);
+    };
+
+    for (const method of manifest.methods ?? []) linkOwner(method);
+    for (const prototype of Object.values(prototypes)) linkOwner(prototype);
+
+    manifest.prototypes = Object.keys(prototypes).sort().map(name => prototypes[name]);
+    manifest.enums = Object.keys(enums).sort().map(name => enums[name]);
+    return manifest;
+}
+
+/** Narrows a resolved prototype/enum field to its definition. */
+export function definitionOf<T extends BaseType>(value: T | string | undefined): T | undefined {
+    return typeof value === 'string' ? undefined : value;
+}
+