Add plugin for TypeStrong/typedoc#2775

Author: awa-xima

build/bin/docs.mjs

@@ -33,6 +33,7 @@ function createTypeDocOptionsForFrontendProjects(frontendProjects) {
         out: DocsDir,
         tsconfig: tsConfig,
         plugin: [
+            "./build/typedoc-plugin/typeof-class-plugin.mjs",
             "typedoc-plugin-merge-modules",
             // "typedoc-plugin-missing-exports",
             "typedoc-plugin-dt-links",

build/common/find-frontend-projects.mjs

@@ -1,7 +1,7 @@
 import path from "node:path";
 import fs from "node:fs/promises";
 
-import { assertDoesNotExist, assertExistsAndIsFile, ensureDirectoryExists, existsAndIsDirectory, existsAndIsFile } from "./file.mjs";
+import { assertDoesNotExist, assertExistsAndIsFile, ensureDirectoryExists, existsAndIsFile } from "./file.mjs";
 import { PackagesDir } from "./environment.mjs";
 
 /**

build/tsconfig.json

@@ -11,5 +11,5 @@
 		"types": ["node"],
 		"lib": ["esnext"],
 	},
-	"include": ["bin", "common", "esbuild-plugin"]
+	"include": ["bin", "common", "esbuild-plugin", "typedoc-plugin"]
 }

build/typedoc-plugin/typeof-class-plugin.mjs

@@ -0,0 +1,80 @@
+/** @import { Application, DeclarationReflection } from "typedoc" */
+
+import { Converter, ReflectionKind } from "typedoc";
+
+/** @param {DeclarationReflection} declaration */
+function hackInheritance(declaration) {
+    if (!declaration.extendedTypes) {
+        return;
+    }
+
+    for (let i = 0; i < declaration.extendedTypes.length; ++i) {
+        const type = declaration.extendedTypes[i];
+        if (type === undefined) {
+            continue;
+        }
+        if (type.type !== "reference") {
+            continue;
+        }
+        if (!type.reflection) {
+            continue;
+        }
+        
+        const target = /** @type {DeclarationReflection} */(type.reflection);
+        
+        if (target.kindOf(ReflectionKind.ClassOrInterface)) {
+            continue;
+        }
+        
+        const targetType = target.type;
+        if (targetType === undefined || targetType.type !== "query") {
+            continue;
+        }
+        if (!targetType.queryType.reflection?.kindOf(ReflectionKind.ClassOrInterface)) {
+            continue;
+        }
+
+        // We inherit from a property somewhere which is declared as `typeof SomeClass`
+        // So re-point the inheritance to SomeClass
+        declaration.extendedTypes[i] = targetType.queryType;
+    }
+}
+
+/**
+ * Plugin for TypeDoc to handle `typeof` class inheritance. When `X` is
+ * a class, `A = X` is a variable assigned to the class with a declared
+ * type of `typeof X`, and another class uses `A` as a base class, then
+ * TypeDoc will not resolve the class hierarchy correctly. For example,
+ * 
+ * ```ts
+ * class X {}
+ * 
+ * interface Registry {
+ *   X: typeof X;
+ * }
+ * declare const registry: Registry;
+ * 
+ * class Y extends registry.X {}
+ * ```
+ * 
+ * This plugin scans for such cases where a class has an expression
+ * in its extends clause. If it finds the type of the expression is
+ * `typeof X`, it replaces the extends clause with `X`. This way,
+ * the class hierarchy is correctly resolved.
+ * 
+ * See also:
+ * https://github.com/TypeStrong/typedoc/issues/2775
+ * 
+ * @param {Application} app 
+ */
+export function load(app) {
+    app.converter.on(
+        Converter.EVENT_RESOLVE_BEGIN,
+        (context) => {
+            for (const decl of context.project.getReflectionsByKind(ReflectionKind.ClassOrInterface)) {
+                hackInheritance(/** @type {DeclarationReflection} */(decl));
+            }
+        },
+        1e6,
+    );
+}

packages/components/index.ts

@@ -1,16 +1,20 @@
+import { InputText } from "./src/InputText.js";
 import { InputTextArea } from "./src/InputTextArea.js";
 
 declare global {
     namespace PrimeType {
         export interface WidgetRegistry {
+            InputText: typeof InputText;
             InputTextArea: typeof InputTextArea;
         }
     }
     namespace PrimeType.widget {
+        export type InputText = import("./src/InputText.js").InputText;
         export type InputTextAreaCfg = import("./src/InputTextArea.js").InputTextAreaCfg;
     }
 }
 
 // @ts-expect-errors
 (window.PrimeFaces ??= {}).widget ??= {};
-PrimeFaces.widget.BaseWidget = InputTextArea;
+PrimeFaces.widget.InputText = InputText;
+PrimeFaces.widget.InputTextArea = InputTextArea;

packages/components/src/InputText.ts

@@ -0,0 +1,20 @@
+export interface InputTextCfg extends PrimeType.widget.BaseWidgetCfg {
+    id: string;
+    resize: boolean;
+}
+
+export class InputText extends PrimeFaces.widget.BaseWidget {
+    readonly input: string;
+    constructor(cfg: InputTextCfg) {
+        super(cfg);
+        this.input = "textarea";
+    }
+
+    focus(): void {
+        this.jq.focus();
+    }
+
+    override render(): void {
+        this.jq.animate({ opacity: 0 }, 500);
+    }
+}