@depup/typedoc 0.28.17-depup.0

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

@@ -0,0 +1,31 @@
+import { ConverterComponent } from "../components.js";
+import type { Converter } from "../converter.js";
+import { type GlobString } from "#utils";
+import { type EntryPointStrategy } from "#node-utils";
+/**
+ * A handler that tries to find the package.json and readme.md files of the
+ * current project.
+ */
+export declare class PackagePlugin extends ConverterComponent {
+    accessor readme: string;
+    accessor entryPointStrategy: EntryPointStrategy;
+    accessor entryPoints: GlobString[];
+    accessor includeVersion: boolean;
+    /**
+     * The file name of the found readme.md file.
+     */
+    private readmeFile?;
+    /**
+     * Contents of the readme.md file discovered, if any
+     */
+    private readmeContents?;
+    /**
+     * Contents of package.json for the active project
+     */
+    private packageJson?;
+    constructor(owner: Converter);
+    private onRevive;
+    private onBegin;
+    private onBeginResolve;
+    private addEntries;
+}

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

@@ -0,0 +1,188 @@
+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;
+};
+import * as Path from "path";
+import { ConverterComponent } from "../components.js";
+import { ApplicationEvents } from "../../application-events.js";
+import { ConverterEvents } from "../converter-events.js";
+import { i18n, MinimalSourceFile, NormalizedPathUtils } from "#utils";
+import { deriveRootDir, discoverPackageJson, nicePath, normalizePath, Option, readFile, } from "#node-utils";
+import { existsSync } from "fs";
+/**
+ * A handler that tries to find the package.json and readme.md files of the
+ * current project.
+ */
+let PackagePlugin = (() => {
+    let _classSuper = ConverterComponent;
+    let _readme_decorators;
+    let _readme_initializers = [];
+    let _readme_extraInitializers = [];
+    let _entryPointStrategy_decorators;
+    let _entryPointStrategy_initializers = [];
+    let _entryPointStrategy_extraInitializers = [];
+    let _entryPoints_decorators;
+    let _entryPoints_initializers = [];
+    let _entryPoints_extraInitializers = [];
+    let _includeVersion_decorators;
+    let _includeVersion_initializers = [];
+    let _includeVersion_extraInitializers = [];
+    return class PackagePlugin extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _readme_decorators = [Option("readme")];
+            _entryPointStrategy_decorators = [Option("entryPointStrategy")];
+            _entryPoints_decorators = [Option("entryPoints")];
+            _includeVersion_decorators = [Option("includeVersion")];
+            __esDecorate(this, null, _readme_decorators, { kind: "accessor", name: "readme", static: false, private: false, access: { has: obj => "readme" in obj, get: obj => obj.readme, set: (obj, value) => { obj.readme = value; } }, metadata: _metadata }, _readme_initializers, _readme_extraInitializers);
+            __esDecorate(this, null, _entryPointStrategy_decorators, { kind: "accessor", name: "entryPointStrategy", static: false, private: false, access: { has: obj => "entryPointStrategy" in obj, get: obj => obj.entryPointStrategy, set: (obj, value) => { obj.entryPointStrategy = value; } }, metadata: _metadata }, _entryPointStrategy_initializers, _entryPointStrategy_extraInitializers);
+            __esDecorate(this, null, _entryPoints_decorators, { kind: "accessor", name: "entryPoints", static: false, private: false, access: { has: obj => "entryPoints" in obj, get: obj => obj.entryPoints, set: (obj, value) => { obj.entryPoints = value; } }, metadata: _metadata }, _entryPoints_initializers, _entryPoints_extraInitializers);
+            __esDecorate(this, null, _includeVersion_decorators, { kind: "accessor", name: "includeVersion", static: false, private: false, access: { has: obj => "includeVersion" in obj, get: obj => obj.includeVersion, set: (obj, value) => { obj.includeVersion = value; } }, metadata: _metadata }, _includeVersion_initializers, _includeVersion_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        #readme_accessor_storage = __runInitializers(this, _readme_initializers, void 0);
+        get readme() { return this.#readme_accessor_storage; }
+        set readme(value) { this.#readme_accessor_storage = value; }
+        #entryPointStrategy_accessor_storage = (__runInitializers(this, _readme_extraInitializers), __runInitializers(this, _entryPointStrategy_initializers, void 0));
+        get entryPointStrategy() { return this.#entryPointStrategy_accessor_storage; }
+        set entryPointStrategy(value) { this.#entryPointStrategy_accessor_storage = value; }
+        #entryPoints_accessor_storage = (__runInitializers(this, _entryPointStrategy_extraInitializers), __runInitializers(this, _entryPoints_initializers, void 0));
+        get entryPoints() { return this.#entryPoints_accessor_storage; }
+        set entryPoints(value) { this.#entryPoints_accessor_storage = value; }
+        #includeVersion_accessor_storage = (__runInitializers(this, _entryPoints_extraInitializers), __runInitializers(this, _includeVersion_initializers, void 0));
+        get includeVersion() { return this.#includeVersion_accessor_storage; }
+        set includeVersion(value) { this.#includeVersion_accessor_storage = value; }
+        /**
+         * The file name of the found readme.md file.
+         */
+        readmeFile = __runInitializers(this, _includeVersion_extraInitializers);
+        /**
+         * Contents of the readme.md file discovered, if any
+         */
+        readmeContents;
+        /**
+         * Contents of package.json for the active project
+         */
+        packageJson;
+        constructor(owner) {
+            super(owner);
+            this.owner.on(ConverterEvents.BEGIN, this.onBegin.bind(this));
+            this.owner.on(ConverterEvents.RESOLVE_BEGIN, this.onBeginResolve.bind(this));
+            this.owner.on(ConverterEvents.END, () => {
+                delete this.readmeFile;
+                delete this.readmeContents;
+                delete this.packageJson;
+            });
+            this.application.on(ApplicationEvents.REVIVE, this.onRevive.bind(this));
+        }
+        onRevive(project) {
+            this.onBegin();
+            this.addEntries(project);
+            delete this.readmeFile;
+            delete this.packageJson;
+            delete this.readmeContents;
+        }
+        onBegin() {
+            this.readmeFile = undefined;
+            this.readmeContents = undefined;
+            this.packageJson = undefined;
+            const dirName = this.application.options.packageDir ??
+                Path.resolve(deriveRootDir(this.entryPoints));
+            this.application.logger.verbose(`Begin package.json search at ${nicePath(dirName)}`);
+            const packageJson = discoverPackageJson(dirName);
+            this.packageJson = packageJson?.content;
+            // Path will be resolved already. This is kind of ugly, but...
+            if (this.readme.endsWith("none")) {
+                return; // No readme, we're done
+            }
+            if (this.readme) {
+                // Readme path provided, read only that file.
+                this.application.watchFile(this.readme);
+                try {
+                    this.readmeContents = readFile(this.readme);
+                    this.readmeFile = normalizePath(this.readme);
+                }
+                catch {
+                    this.application.logger.error(i18n.provided_readme_at_0_could_not_be_read(nicePath(this.readme)));
+                }
+            }
+            else if (packageJson) {
+                // No readme provided, automatically find the readme
+                const possibleReadmePaths = [
+                    "README.md",
+                    "readme.md",
+                    "Readme.md",
+                ].map(name => Path.join(Path.dirname(packageJson.file), name));
+                const readmePath = possibleReadmePaths.find(path => {
+                    this.application.watchFile(path);
+                    return existsSync(path);
+                });
+                if (readmePath) {
+                    this.readmeFile = normalizePath(readmePath);
+                    this.readmeContents = readFile(readmePath);
+                    this.application.watchFile(this.readmeFile);
+                }
+            }
+        }
+        onBeginResolve(context) {
+            this.addEntries(context.project);
+        }
+        addEntries(project) {
+            if (this.readmeFile && this.readmeContents) {
+                const { content } = this.application.converter.parseRawComment(new MinimalSourceFile(this.readmeContents, this.readmeFile), project.files);
+                project.readme = content;
+                project.files.registerReflectionPath(this.readmeFile, project);
+                // In packages mode, this probably won't do anything unless someone uses the readme
+                // option to select a different file.
+                project.files.registerReflectionPath(NormalizedPathUtils.dirname(this.readmeFile), project);
+                // This isn't ideal, but seems better than figuring out the readme
+                // path over in the include plugin...
+                this.owner.includePlugin.checkIncludeTagsParts(project, Path.dirname(this.readmeFile), content);
+            }
+            if (this.packageJson) {
+                project.packageName = this.packageJson.name;
+                if (!project.name) {
+                    project.name = project.packageName || "Documentation";
+                }
+                if (this.includeVersion) {
+                    project.packageVersion = this.packageJson.version?.replace(/^v/, "");
+                }
+            }
+            else if (!project.name) {
+                this.application.logger.warn(i18n.defaulting_project_name());
+                project.name = "Documentation";
+            }
+        }
+    };
+})();
+export { PackagePlugin };

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

@@ -0,0 +1,36 @@
+import { ConverterComponent } from "../components.js";
+import type { Converter } from "../converter.js";
+/**
+ * A handler that attaches source file information to reflections.
+ */
+export declare class SourcePlugin extends ConverterComponent {
+    accessor disableSources: boolean;
+    accessor gitRevision: string;
+    accessor gitRemote: string;
+    accessor disableGit: boolean;
+    accessor sourceLinkTemplate: string;
+    get displayBasePath(): import("#utils").NormalizedPath;
+    /**
+     * All file names to find the base path from.
+     */
+    private fileNames;
+    private repositories?;
+    constructor(owner: Converter);
+    private onEnd;
+    /**
+     * Triggered when the converter has created a declaration reflection.
+     *
+     * Attach the current source file to the {@link DeclarationReflection.sources} array.
+     *
+     * @param _context  The context object describing the current state the converter is in.
+     * @param reflection  The reflection that is currently processed.
+     */
+    private onDeclaration;
+    private onSignature;
+    /**
+     * Triggered when the converter begins resolving a project.
+     *
+     * @param context  The context object describing the current state the converter is in.
+     */
+    private onBeginResolve;
+}

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

@@ -0,0 +1,215 @@
+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;
+};
+import ts from "typescript";
+import { DeclarationReflection, ReflectionKind, SignatureReflection } from "../../models/index.js";
+import { ConverterComponent } from "../components.js";
+import { getCommonDirectory, normalizePath, Option } from "../../utils/index.js";
+import { isNamedNode } from "../utils/nodes.js";
+import { relative } from "path";
+import { SourceReference } from "../../models/index.js";
+import { gitIsInstalled, RepositoryManager } from "../utils/repository.js";
+import { ConverterEvents } from "../converter-events.js";
+import { i18n } from "#utils";
+/**
+ * A handler that attaches source file information to reflections.
+ */
+let SourcePlugin = (() => {
+    let _classSuper = ConverterComponent;
+    let _disableSources_decorators;
+    let _disableSources_initializers = [];
+    let _disableSources_extraInitializers = [];
+    let _gitRevision_decorators;
+    let _gitRevision_initializers = [];
+    let _gitRevision_extraInitializers = [];
+    let _gitRemote_decorators;
+    let _gitRemote_initializers = [];
+    let _gitRemote_extraInitializers = [];
+    let _disableGit_decorators;
+    let _disableGit_initializers = [];
+    let _disableGit_extraInitializers = [];
+    let _sourceLinkTemplate_decorators;
+    let _sourceLinkTemplate_initializers = [];
+    let _sourceLinkTemplate_extraInitializers = [];
+    return class SourcePlugin extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _disableSources_decorators = [Option("disableSources")];
+            _gitRevision_decorators = [Option("gitRevision")];
+            _gitRemote_decorators = [Option("gitRemote")];
+            _disableGit_decorators = [Option("disableGit")];
+            _sourceLinkTemplate_decorators = [Option("sourceLinkTemplate")];
+            __esDecorate(this, null, _disableSources_decorators, { kind: "accessor", name: "disableSources", static: false, private: false, access: { has: obj => "disableSources" in obj, get: obj => obj.disableSources, set: (obj, value) => { obj.disableSources = value; } }, metadata: _metadata }, _disableSources_initializers, _disableSources_extraInitializers);
+            __esDecorate(this, null, _gitRevision_decorators, { kind: "accessor", name: "gitRevision", static: false, private: false, access: { has: obj => "gitRevision" in obj, get: obj => obj.gitRevision, set: (obj, value) => { obj.gitRevision = value; } }, metadata: _metadata }, _gitRevision_initializers, _gitRevision_extraInitializers);
+            __esDecorate(this, null, _gitRemote_decorators, { kind: "accessor", name: "gitRemote", static: false, private: false, access: { has: obj => "gitRemote" in obj, get: obj => obj.gitRemote, set: (obj, value) => { obj.gitRemote = value; } }, metadata: _metadata }, _gitRemote_initializers, _gitRemote_extraInitializers);
+            __esDecorate(this, null, _disableGit_decorators, { kind: "accessor", name: "disableGit", static: false, private: false, access: { has: obj => "disableGit" in obj, get: obj => obj.disableGit, set: (obj, value) => { obj.disableGit = value; } }, metadata: _metadata }, _disableGit_initializers, _disableGit_extraInitializers);
+            __esDecorate(this, null, _sourceLinkTemplate_decorators, { kind: "accessor", name: "sourceLinkTemplate", static: false, private: false, access: { has: obj => "sourceLinkTemplate" in obj, get: obj => obj.sourceLinkTemplate, set: (obj, value) => { obj.sourceLinkTemplate = value; } }, metadata: _metadata }, _sourceLinkTemplate_initializers, _sourceLinkTemplate_extraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        #disableSources_accessor_storage = __runInitializers(this, _disableSources_initializers, void 0);
+        get disableSources() { return this.#disableSources_accessor_storage; }
+        set disableSources(value) { this.#disableSources_accessor_storage = value; }
+        #gitRevision_accessor_storage = (__runInitializers(this, _disableSources_extraInitializers), __runInitializers(this, _gitRevision_initializers, void 0));
+        get gitRevision() { return this.#gitRevision_accessor_storage; }
+        set gitRevision(value) { this.#gitRevision_accessor_storage = value; }
+        #gitRemote_accessor_storage = (__runInitializers(this, _gitRevision_extraInitializers), __runInitializers(this, _gitRemote_initializers, void 0));
+        get gitRemote() { return this.#gitRemote_accessor_storage; }
+        set gitRemote(value) { this.#gitRemote_accessor_storage = value; }
+        #disableGit_accessor_storage = (__runInitializers(this, _gitRemote_extraInitializers), __runInitializers(this, _disableGit_initializers, void 0));
+        get disableGit() { return this.#disableGit_accessor_storage; }
+        set disableGit(value) { this.#disableGit_accessor_storage = value; }
+        #sourceLinkTemplate_accessor_storage = (__runInitializers(this, _disableGit_extraInitializers), __runInitializers(this, _sourceLinkTemplate_initializers, void 0));
+        get sourceLinkTemplate() { return this.#sourceLinkTemplate_accessor_storage; }
+        set sourceLinkTemplate(value) { this.#sourceLinkTemplate_accessor_storage = value; }
+        get displayBasePath() {
+            return this.application.options.getValue("displayBasePath") || this.application.options.getValue("basePath");
+        }
+        /**
+         * All file names to find the base path from.
+         */
+        fileNames = (__runInitializers(this, _sourceLinkTemplate_extraInitializers), new Set());
+        repositories;
+        constructor(owner) {
+            super(owner);
+            this.owner.on(ConverterEvents.END, this.onEnd.bind(this));
+            this.owner.on(ConverterEvents.CREATE_DECLARATION, this.onDeclaration.bind(this));
+            this.owner.on(ConverterEvents.CREATE_SIGNATURE, this.onSignature.bind(this));
+            this.owner.on(ConverterEvents.RESOLVE_BEGIN, this.onBeginResolve.bind(this));
+        }
+        onEnd() {
+            this.fileNames.clear();
+            delete this.repositories;
+        }
+        /**
+         * Triggered when the converter has created a declaration reflection.
+         *
+         * Attach the current source file to the {@link DeclarationReflection.sources} array.
+         *
+         * @param _context  The context object describing the current state the converter is in.
+         * @param reflection  The reflection that is currently processed.
+         */
+        onDeclaration(context, reflection) {
+            if (this.disableSources || reflection.kindOf(ReflectionKind.TypeLiteral))
+                return;
+            const symbol = context.getSymbolFromReflection(reflection);
+            for (const node of symbol?.declarations || []) {
+                const sourceFile = node.getSourceFile();
+                const fileName = normalizePath(sourceFile.fileName);
+                this.fileNames.add(fileName);
+                let position;
+                if (ts.isSourceFile(node)) {
+                    position = { character: 0, line: 0 };
+                }
+                else {
+                    position = ts.getLineAndCharacterOfPosition(sourceFile, getLocationNode(node).getStart());
+                }
+                reflection.sources ||= [];
+                reflection.sources.push(new SourceReference(fileName, position.line + 1, position.character));
+            }
+        }
+        onSignature(_context, reflection, sig) {
+            if (this.disableSources || !sig || reflection.parent.kindOf(ReflectionKind.TypeLiteral))
+                return;
+            const sourceFile = sig.getSourceFile();
+            const fileName = normalizePath(sourceFile.fileName);
+            this.fileNames.add(fileName);
+            const position = ts.getLineAndCharacterOfPosition(sourceFile, getLocationNode(sig).getStart());
+            reflection.sources ||= [];
+            reflection.sources.push(new SourceReference(fileName, position.line + 1, position.character));
+        }
+        /**
+         * Triggered when the converter begins resolving a project.
+         *
+         * @param context  The context object describing the current state the converter is in.
+         */
+        onBeginResolve(context) {
+            if (this.disableSources)
+                return;
+            if (this.disableGit && !this.sourceLinkTemplate) {
+                this.application.logger.error(i18n.disable_git_set_but_not_source_link_template());
+                return;
+            }
+            if (this.disableGit &&
+                this.sourceLinkTemplate.includes("{gitRevision}") &&
+                !this.gitRevision) {
+                this.application.logger.warn(i18n.disable_git_set_and_git_revision_used());
+            }
+            const basePath = this.displayBasePath || getCommonDirectory([...this.fileNames]);
+            this.repositories ||= new RepositoryManager(basePath, this.gitRevision, this.gitRemote, this.sourceLinkTemplate, this.disableGit, this.application.logger);
+            for (const id in context.project.reflections) {
+                const refl = context.project.reflections[id];
+                if (!(refl instanceof DeclarationReflection ||
+                    refl instanceof SignatureReflection)) {
+                    continue;
+                }
+                if (replaceSourcesWithParentSources(context, refl)) {
+                    refl.sources = refl.parent.sources;
+                }
+                for (const source of refl.sources || []) {
+                    if (this.disableGit || gitIsInstalled()) {
+                        const repo = this.repositories.getRepository(source.fullFileName);
+                        source.url = repo?.getURL(source.fullFileName, source.line);
+                    }
+                    source.fileName = normalizePath(relative(basePath, source.fullFileName));
+                }
+            }
+        }
+    };
+})();
+export { SourcePlugin };
+function getLocationNode(node) {
+    if (isNamedNode(node))
+        return node.name;
+    return node;
+}
+function replaceSourcesWithParentSources(context, refl) {
+    if (refl instanceof DeclarationReflection || !refl.sources) {
+        return false;
+    }
+    const symbol = context.getSymbolFromReflection(refl.parent);
+    if (!symbol?.declarations) {
+        return false;
+    }
+    for (const decl of symbol.declarations) {
+        const file = decl.getSourceFile();
+        const pos = file.getLineAndCharacterOfPosition(decl.pos);
+        const end = file.getLineAndCharacterOfPosition(decl.end);
+        if (refl.sources.some((src) => src.fullFileName === file.fileName &&
+            pos.line <= src.line - 1 &&
+            src.line - 1 <= end.line)) {
+            return false;
+        }
+    }
+    return true;
+}

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

@@ -0,0 +1,16 @@
+import { DeclarationReflection } from "../../models/index.js";
+import { ConverterComponent } from "../components.js";
+import type { Converter } from "../converter.js";
+/**
+ * Responsible for adding `implementedBy` / `implementedFrom`
+ */
+export declare class TypePlugin extends ConverterComponent {
+    reflections: Set<DeclarationReflection>;
+    constructor(owner: Converter);
+    private onRevive;
+    private onResolve;
+    private resolve;
+    private postpone;
+    private onResolveEnd;
+    private finishResolve;
+}

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

@@ -0,0 +1,108 @@
+import { DeclarationReflection, ReflectionKind, } from "../../models/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`
+ */
+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), 100);
+    }
+    onRevive(project) {
+        for (const id in project.reflections) {
+            this.resolve(project, project.reflections[id]);
+        }
+        this.finishResolve(project);
+        this.reflections.clear();
+    }
+    onResolve(context, reflection) {
+        this.resolve(context.project, reflection);
+    }
+    resolve(project, reflection) {
+        if (!(reflection instanceof DeclarationReflection))
+            return;
+        if (reflection.kindOf(ReflectionKind.ClassOrInterface)) {
+            this.postpone(reflection);
+            walk(reflection.implementedTypes, (target) => {
+                this.postpone(target);
+                target.implementedBy ||= [];
+                if (!target.implementedBy.some((t) => t.reflection === reflection)) {
+                    target.implementedBy.push(ReferenceType.createResolvedReference(reflection.name, reflection, project));
+                }
+            });
+            walk(reflection.extendedTypes, (target) => {
+                this.postpone(target);
+                target.extendedBy ||= [];
+                if (!target.extendedBy.some((t) => t.reflection === reflection)) {
+                    target.extendedBy.push(ReferenceType.createResolvedReference(reflection.name, reflection, project));
+                }
+            });
+        }
+        function walk(types, callback) {
+            if (!types) {
+                return;
+            }
+            types.forEach((type) => {
+                if (!(type instanceof ReferenceType)) {
+                    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;
+                    }
+                    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([
+                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

@@ -0,0 +1,10 @@
+export { CategoryPlugin } from "./CategoryPlugin.js";
+export { CommentPlugin } from "./CommentPlugin.js";
+export { GroupPlugin } from "./GroupPlugin.js";
+export { ImplementsPlugin } from "./ImplementsPlugin.js";
+export { IncludePlugin } from "./IncludePlugin.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";

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

@@ -0,0 +1,10 @@
+export { CategoryPlugin } from "./CategoryPlugin.js";
+export { CommentPlugin } from "./CommentPlugin.js";
+export { GroupPlugin } from "./GroupPlugin.js";
+export { ImplementsPlugin } from "./ImplementsPlugin.js";
+export { IncludePlugin } from "./IncludePlugin.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";

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

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