typedoc 0.26.11 → 0.27.0-beta.1

package/dist/lib/converter/plugins/TypePlugin.js

@@ -1,172 +1,109 @@
-"use strict";
-var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-};
-var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-};
-var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
-    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
-    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypePlugin = void 0;
-const index_1 = require("../../models/reflections/index");
-const types_1 = require("../../models/types");
-const components_1 = require("../components");
-const converter_1 = require("../converter");
-const application_events_1 = require("../../application-events");
+import { ReflectionKind, DeclarationReflection, } from "../../models/reflections/index.js";
+import { ReferenceType } from "../../models/types.js";
+import { ConverterComponent } from "../components.js";
+import { ApplicationEvents } from "../../application-events.js";
+import { ConverterEvents } from "../converter-events.js";
 /**
  * Responsible for adding `implementedBy` / `implementedFrom`
  */
-let TypePlugin = (() => {
-    let _classDecorators = [(0, components_1.Component)({ name: "type" })];
-    let _classDescriptor;
-    let _classExtraInitializers = [];
-    let _classThis;
-    let _classSuper = components_1.ConverterComponent;
-    var TypePlugin = _classThis = class extends _classSuper {
-        constructor() {
-            super(...arguments);
-            this.reflections = new Set();
-        }
-        /**
-         * Create a new TypeHandler instance.
-         */
-        initialize() {
-            this.owner.on(converter_1.Converter.EVENT_RESOLVE, this.onResolve.bind(this));
-            this.owner.on(converter_1.Converter.EVENT_RESOLVE_END, this.onResolveEnd.bind(this));
-            this.owner.on(converter_1.Converter.EVENT_END, () => this.reflections.clear());
-            this.application.on(application_events_1.ApplicationEvents.REVIVE, this.onRevive.bind(this));
-        }
-        onRevive(project) {
-            for (const id in project.reflections) {
-                this.resolve(project, project.reflections[id], 
-                /* create links */ false);
-            }
-            this.finishResolve(project);
-            this.reflections.clear();
+export class TypePlugin extends ConverterComponent {
+    reflections = new Set();
+    constructor(owner) {
+        super(owner);
+        this.owner.on(ConverterEvents.RESOLVE, this.onResolve.bind(this));
+        this.owner.on(ConverterEvents.RESOLVE_END, this.onResolveEnd.bind(this));
+        this.owner.on(ConverterEvents.END, () => this.reflections.clear());
+        this.application.on(ApplicationEvents.REVIVE, this.onRevive.bind(this));
+    }
+    onRevive(project) {
+        for (const id in project.reflections) {
+            this.resolve(project, project.reflections[id], 
+            /* create links */ false);
         }
-        onResolve(context, reflection) {
-            this.resolve(context.project, reflection);
+        this.finishResolve(project);
+        this.reflections.clear();
+    }
+    onResolve(context, reflection) {
+        this.resolve(context.project, reflection);
+    }
+    resolve(project, reflection, createLinks = true) {
+        if (!(reflection instanceof DeclarationReflection))
+            return;
+        if (reflection.kindOf(ReflectionKind.ClassOrInterface)) {
+            this.postpone(reflection);
+            walk(reflection.implementedTypes, (target) => {
+                this.postpone(target);
+                target.implementedBy ||= [];
+                if (createLinks) {
+                    target.implementedBy.push(ReferenceType.createResolvedReference(reflection.name, reflection, project));
+                }
+            });
+            walk(reflection.extendedTypes, (target) => {
+                this.postpone(target);
+                target.extendedBy ||= [];
+                if (createLinks) {
+                    target.extendedBy.push(ReferenceType.createResolvedReference(reflection.name, reflection, project));
+                }
+            });
         }
-        resolve(project, reflection, createLinks = true) {
-            if (!(reflection instanceof index_1.DeclarationReflection))
+        function walk(types, callback) {
+            if (!types) {
                 return;
-            if (reflection.kindOf(index_1.ReflectionKind.ClassOrInterface)) {
-                this.postpone(reflection);
-                walk(reflection.implementedTypes, (target) => {
-                    this.postpone(target);
-                    target.implementedBy ||= [];
-                    if (createLinks) {
-                        target.implementedBy.push(types_1.ReferenceType.createResolvedReference(reflection.name, reflection, project));
-                    }
-                });
-                walk(reflection.extendedTypes, (target) => {
-                    this.postpone(target);
-                    target.extendedBy ||= [];
-                    if (createLinks) {
-                        target.extendedBy.push(types_1.ReferenceType.createResolvedReference(reflection.name, reflection, project));
-                    }
-                });
             }
-            function walk(types, callback) {
-                if (!types) {
+            types.forEach((type) => {
+                if (!(type instanceof ReferenceType)) {
                     return;
                 }
-                types.forEach((type) => {
-                    if (!(type instanceof types_1.ReferenceType)) {
-                        return;
-                    }
-                    if (!type.reflection ||
-                        !(type.reflection instanceof index_1.DeclarationReflection)) {
-                        return;
+                if (!type.reflection ||
+                    !(type.reflection instanceof DeclarationReflection)) {
+                    return;
+                }
+                callback(type.reflection);
+            });
+        }
+    }
+    postpone(reflection) {
+        this.reflections.add(reflection);
+    }
+    onResolveEnd(context) {
+        this.finishResolve(context.project);
+    }
+    finishResolve(project) {
+        this.reflections.forEach((reflection) => {
+            if (reflection.implementedBy) {
+                reflection.implementedBy.sort((a, b) => {
+                    if (a.name === b.name) {
+                        return 0;
                     }
-                    callback(type.reflection);
+                    return a.name > b.name ? 1 : -1;
                 });
             }
-        }
-        postpone(reflection) {
-            this.reflections.add(reflection);
-        }
-        onResolveEnd(context) {
-            this.finishResolve(context.project);
-        }
-        finishResolve(project) {
-            this.reflections.forEach((reflection) => {
-                if (reflection.implementedBy) {
-                    reflection.implementedBy.sort((a, b) => {
-                        if (a.name === b.name) {
-                            return 0;
-                        }
-                        return a.name > b.name ? 1 : -1;
-                    });
-                }
-                let root;
-                let hierarchy;
-                function push(types) {
-                    const level = { types: types };
-                    if (hierarchy) {
-                        hierarchy.next = level;
-                        hierarchy = level;
-                    }
-                    else {
-                        root = hierarchy = level;
-                    }
-                }
-                if (reflection.extendedTypes) {
-                    push(reflection.extendedTypes);
-                }
-                push([
-                    types_1.ReferenceType.createResolvedReference(reflection.name, reflection, project),
-                ]);
-                hierarchy.isTarget = true;
-                if (reflection.extendedBy) {
-                    push(reflection.extendedBy);
+            let root;
+            let hierarchy;
+            function push(types) {
+                const level = { types: types };
+                if (hierarchy) {
+                    hierarchy.next = level;
+                    hierarchy = level;
                 }
-                // No point setting up a hierarchy if there is no hierarchy to display
-                if (root.next) {
-                    reflection.typeHierarchy = root;
+                else {
+                    root = hierarchy = level;
                 }
-            });
-        }
-    };
-    __setFunctionName(_classThis, "TypePlugin");
-    (() => {
-        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-        TypePlugin = _classThis = _classDescriptor.value;
-        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        __runInitializers(_classThis, _classExtraInitializers);
-    })();
-    return TypePlugin = _classThis;
-})();
-exports.TypePlugin = TypePlugin;
+            }
+            if (reflection.extendedTypes) {
+                push(reflection.extendedTypes);
+            }
+            push([
+                ReferenceType.createResolvedReference(reflection.name, reflection, project),
+            ]);
+            hierarchy.isTarget = true;
+            if (reflection.extendedBy) {
+                push(reflection.extendedBy);
+            }
+            // No point setting up a hierarchy if there is no hierarchy to display
+            if (root.next) {
+                reflection.typeHierarchy = root;
+            }
+        });
+    }
+}

package/dist/lib/converter/plugins/index.d.ts

@@ -1,9 +1,10 @@
-export { CategoryPlugin } from "./CategoryPlugin";
-export { CommentPlugin } from "./CommentPlugin";
-export { GroupPlugin } from "./GroupPlugin";
-export { ImplementsPlugin } from "./ImplementsPlugin";
-export { InheritDocPlugin } from "./InheritDocPlugin";
-export { LinkResolverPlugin } from "./LinkResolverPlugin";
-export { PackagePlugin } from "./PackagePlugin";
-export { SourcePlugin } from "./SourcePlugin";
-export { TypePlugin } from "./TypePlugin";
+export { CategoryPlugin } from "./CategoryPlugin.js";
+export { CommentPlugin } from "./CommentPlugin.js";
+export { GroupPlugin } from "./GroupPlugin.js";
+export { ImplementsPlugin } from "./ImplementsPlugin.js";
+export { InheritDocPlugin } from "./InheritDocPlugin.js";
+export { LinkResolverPlugin } from "./LinkResolverPlugin.js";
+export { PackagePlugin } from "./PackagePlugin.js";
+export { SourcePlugin } from "./SourcePlugin.js";
+export { TypePlugin } from "./TypePlugin.js";
+export { IncludePlugin } from "./IncludePlugin.js";

package/dist/lib/converter/plugins/index.js

@@ -1,21 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TypePlugin = exports.SourcePlugin = exports.PackagePlugin = exports.LinkResolverPlugin = exports.InheritDocPlugin = exports.ImplementsPlugin = exports.GroupPlugin = exports.CommentPlugin = exports.CategoryPlugin = void 0;
-var CategoryPlugin_1 = require("./CategoryPlugin");
-Object.defineProperty(exports, "CategoryPlugin", { enumerable: true, get: function () { return CategoryPlugin_1.CategoryPlugin; } });
-var CommentPlugin_1 = require("./CommentPlugin");
-Object.defineProperty(exports, "CommentPlugin", { enumerable: true, get: function () { return CommentPlugin_1.CommentPlugin; } });
-var GroupPlugin_1 = require("./GroupPlugin");
-Object.defineProperty(exports, "GroupPlugin", { enumerable: true, get: function () { return GroupPlugin_1.GroupPlugin; } });
-var ImplementsPlugin_1 = require("./ImplementsPlugin");
-Object.defineProperty(exports, "ImplementsPlugin", { enumerable: true, get: function () { return ImplementsPlugin_1.ImplementsPlugin; } });
-var InheritDocPlugin_1 = require("./InheritDocPlugin");
-Object.defineProperty(exports, "InheritDocPlugin", { enumerable: true, get: function () { return InheritDocPlugin_1.InheritDocPlugin; } });
-var LinkResolverPlugin_1 = require("./LinkResolverPlugin");
-Object.defineProperty(exports, "LinkResolverPlugin", { enumerable: true, get: function () { return LinkResolverPlugin_1.LinkResolverPlugin; } });
-var PackagePlugin_1 = require("./PackagePlugin");
-Object.defineProperty(exports, "PackagePlugin", { enumerable: true, get: function () { return PackagePlugin_1.PackagePlugin; } });
-var SourcePlugin_1 = require("./SourcePlugin");
-Object.defineProperty(exports, "SourcePlugin", { enumerable: true, get: function () { return SourcePlugin_1.SourcePlugin; } });
-var TypePlugin_1 = require("./TypePlugin");
-Object.defineProperty(exports, "TypePlugin", { enumerable: true, get: function () { return TypePlugin_1.TypePlugin; } });
+export { CategoryPlugin } from "./CategoryPlugin.js";
+export { CommentPlugin } from "./CommentPlugin.js";
+export { GroupPlugin } from "./GroupPlugin.js";
+export { ImplementsPlugin } from "./ImplementsPlugin.js";
+export { InheritDocPlugin } from "./InheritDocPlugin.js";
+export { LinkResolverPlugin } from "./LinkResolverPlugin.js";
+export { PackagePlugin } from "./PackagePlugin.js";
+export { SourcePlugin } from "./SourcePlugin.js";
+export { TypePlugin } from "./TypePlugin.js";
+export { IncludePlugin } from "./IncludePlugin.js";

package/dist/lib/converter/symbols.d.ts

@@ -1,3 +1,3 @@
 import ts from "typescript";
-import type { Context } from "./context";
+import type { Context } from "./context.js";
 export declare function convertSymbol(context: Context, symbol: ts.Symbol, exportSymbol?: ts.Symbol): void;