typedoc 0.26.10 → 0.27.0-beta.0

package/dist/lib/output/themes/lib.js

@@ -1,39 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringify = stringify;
-exports.getDisplayName = getDisplayName;
-exports.toStyleClass = toStyleClass;
-exports.getKindClass = getKindClass;
-exports.wbr = wbr;
-exports.join = join;
-exports.classNames = classNames;
-exports.hasTypeParameters = hasTypeParameters;
-exports.renderTypeParametersSignature = renderTypeParametersSignature;
-exports.renderName = renderName;
-exports.getHierarchyRoots = getHierarchyRoots;
-const models_1 = require("../../models");
-const utils_1 = require("../../utils");
-function stringify(data) {
+import { DeclarationReflection, ProjectReflection, ReferenceReflection, ReflectionKind, SignatureReflection, } from "../../models/index.js";
+import { DefaultMap, filterMap, JSX } from "../../utils/index.js";
+export function stringify(data) {
     if (typeof data === "bigint") {
         return data.toString() + "n";
     }
     return JSON.stringify(data);
 }
-function getDisplayName(refl) {
+export function getDisplayName(refl) {
     let version = "";
-    if ((refl instanceof models_1.DeclarationReflection || refl instanceof models_1.ProjectReflection) && refl.packageVersion) {
+    if ((refl instanceof DeclarationReflection || refl instanceof ProjectReflection) && refl.packageVersion) {
         version = ` - v${refl.packageVersion}`;
     }
     return `${refl.name}${version}`;
 }
-function toStyleClass(str) {
+export function toStyleClass(str) {
     return str.replace(/(\w)([A-Z])/g, (_m, m1, m2) => m1 + "-" + m2).toLowerCase();
 }
-function getKindClass(refl) {
-    if (refl instanceof models_1.ReferenceReflection) {
+export function getKindClass(refl) {
+    if (refl instanceof ReferenceReflection) {
         return getKindClass(refl.getTargetReflectionDeep());
     }
-    return models_1.ReflectionKind.classString(refl.kind);
+    return ReflectionKind.classString(refl.kind);
 }
 /**
  * Insert word break tags ``<wbr>`` into the given string.
@@ -43,20 +30,20 @@ function getKindClass(refl) {
  * @param str The string that should be split.
  * @return The original string containing ``<wbr>`` tags where possible.
  */
-function wbr(str) {
+export function wbr(str) {
     // TODO surely there is a better way to do this, but I'm tired.
     const ret = [];
     const re = /[\s\S]*?(?:[^_-][_-](?=[^_-])|[^A-Z](?=[A-Z][^A-Z]))/g;
     let match;
     let i = 0;
     while ((match = re.exec(str))) {
-        ret.push(match[0], utils_1.JSX.createElement("wbr", null));
+        ret.push(match[0], JSX.createElement("wbr", null));
         i += match[0].length;
     }
     ret.push(str.slice(i));
     return ret;
 }
-function join(joiner, list, cb) {
+export function join(joiner, list, cb) {
     const result = [];
     for (const item of list) {
         if (result.length > 0) {
@@ -64,9 +51,9 @@ function join(joiner, list, cb) {
         }
         result.push(cb(item));
     }
-    return utils_1.JSX.createElement(utils_1.JSX.Fragment, null, result);
+    return JSX.createElement(JSX.Fragment, null, result);
 }
-function classNames(names, extraCss) {
+export function classNames(names, extraCss) {
     const css = Object.keys(names)
         .filter((key) => names[key])
         .concat(extraCss || "")
@@ -75,48 +62,48 @@ function classNames(names, extraCss) {
         .replace(/\s+/g, " ");
     return css.length ? css : undefined;
 }
-function hasTypeParameters(reflection) {
-    return ((reflection instanceof models_1.DeclarationReflection || reflection instanceof models_1.SignatureReflection) &&
+export function hasTypeParameters(reflection) {
+    return ((reflection instanceof DeclarationReflection || reflection instanceof SignatureReflection) &&
         reflection.typeParameters != null &&
         reflection.typeParameters.length > 0);
 }
-function renderTypeParametersSignature(context, typeParameters) {
+export function renderTypeParametersSignature(context, typeParameters) {
     if (!typeParameters || typeParameters.length === 0)
-        return utils_1.JSX.createElement(utils_1.JSX.Fragment, null);
-    const hideParamTypes = context.options.getValue("hideParameterTypesInTitle");
+        return JSX.createElement(JSX.Fragment, null);
+    const hideParamTypes = false; // context.options.getValue("hideTypesInSignatureTitle");
     if (hideParamTypes) {
-        return (utils_1.JSX.createElement(utils_1.JSX.Fragment, null,
-            utils_1.JSX.createElement("span", { class: "tsd-signature-symbol" }, "<"),
-            join(utils_1.JSX.createElement("span", { class: "tsd-signature-symbol" }, ", "), typeParameters, (item) => (utils_1.JSX.createElement(utils_1.JSX.Fragment, null,
-                item.flags.isConst && utils_1.JSX.createElement("span", { class: "tsd-signature-keyword" }, "const "),
+        return (JSX.createElement(JSX.Fragment, null,
+            JSX.createElement("span", { class: "tsd-signature-symbol" }, "<"),
+            join(JSX.createElement("span", { class: "tsd-signature-symbol" }, ", "), typeParameters, (item) => (JSX.createElement(JSX.Fragment, null,
+                item.flags.isConst && JSX.createElement("span", { class: "tsd-signature-keyword" }, "const "),
                 item.varianceModifier ? `${item.varianceModifier} ` : "",
-                utils_1.JSX.createElement("a", { class: "tsd-signature-type tsd-kind-type-parameter", href: context.urlTo(item) }, item.name)))),
-            utils_1.JSX.createElement("span", { class: "tsd-signature-symbol" }, ">")));
+                JSX.createElement("a", { class: "tsd-signature-type tsd-kind-type-parameter", href: context.urlTo(item) }, item.name)))),
+            JSX.createElement("span", { class: "tsd-signature-symbol" }, ">")));
     }
-    return (utils_1.JSX.createElement(utils_1.JSX.Fragment, null,
-        utils_1.JSX.createElement("span", { class: "tsd-signature-symbol" }, "<"),
-        join(utils_1.JSX.createElement("span", { class: "tsd-signature-symbol" }, ", "), typeParameters, (item) => (utils_1.JSX.createElement(utils_1.JSX.Fragment, null,
+    return (JSX.createElement(JSX.Fragment, null,
+        JSX.createElement("span", { class: "tsd-signature-symbol" }, "<"),
+        join(JSX.createElement("span", { class: "tsd-signature-symbol" }, ", "), typeParameters, (item) => (JSX.createElement(JSX.Fragment, null,
             item.flags.isConst && "const ",
             item.varianceModifier ? `${item.varianceModifier} ` : "",
-            utils_1.JSX.createElement("span", { class: "tsd-signature-type tsd-kind-type-parameter" }, item.name),
-            !!item.type && (utils_1.JSX.createElement(utils_1.JSX.Fragment, null,
-                utils_1.JSX.createElement("span", { class: "tsd-signature-keyword" }, " extends "),
+            JSX.createElement("span", { class: "tsd-signature-type tsd-kind-type-parameter" }, item.name),
+            !!item.type && (JSX.createElement(JSX.Fragment, null,
+                JSX.createElement("span", { class: "tsd-signature-keyword" }, " extends "),
                 context.type(item.type)))))),
-        utils_1.JSX.createElement("span", { class: "tsd-signature-symbol" }, ">")));
+        JSX.createElement("span", { class: "tsd-signature-symbol" }, ">")));
 }
 /**
  * Renders the reflection name with an additional `?` if optional.
  */
-function renderName(refl) {
+export function renderName(refl) {
     if (refl.flags.isOptional) {
-        return utils_1.JSX.createElement(utils_1.JSX.Fragment, null,
+        return JSX.createElement(JSX.Fragment, null,
             wbr(refl.name),
             "?");
     }
     return wbr(refl.name);
 }
-function getHierarchyRoots(project) {
-    const allClasses = project.getReflectionsByKind(models_1.ReflectionKind.ClassOrInterface);
+export function getHierarchyRoots(project) {
+    const allClasses = project.getReflectionsByKind(ReflectionKind.ClassOrInterface);
     const roots = allClasses.filter((refl) => {
         // If nobody extends this class, there's no possible hierarchy to display.
         if (!refl.implementedBy && !refl.extendedBy) {
@@ -137,3 +124,77 @@ function getHierarchyRoots(project) {
     });
     return roots.sort((a, b) => a.name.localeCompare(b.name));
 }
+export function getMemberSections(parent, childFilter = () => true) {
+    if (parent.categories?.length) {
+        return filterMap(parent.categories, (cat) => {
+            const children = cat.children.filter(childFilter);
+            if (!children.length)
+                return;
+            return {
+                title: cat.title,
+                children,
+            };
+        });
+    }
+    if (parent.groups?.length) {
+        return parent.groups.flatMap((group) => {
+            if (group.categories?.length) {
+                return filterMap(group.categories, (cat) => {
+                    const children = cat.children.filter(childFilter);
+                    if (!children.length)
+                        return;
+                    return {
+                        title: `${group.title} - ${cat.title}`,
+                        children,
+                    };
+                });
+            }
+            const children = group.children.filter(childFilter);
+            if (!children.length)
+                return [];
+            return {
+                title: group.title,
+                children,
+            };
+        });
+    }
+    return [];
+}
+const nameCollisionCache = new WeakMap();
+function getNameCollisionCount(project, name) {
+    let collisions = nameCollisionCache.get(project);
+    if (collisions === undefined) {
+        collisions = new DefaultMap(() => 0);
+        for (const reflection of project.getReflectionsByKind(ReflectionKind.SomeExport)) {
+            collisions.set(reflection.name, collisions.get(reflection.name) + 1);
+        }
+        nameCollisionCache.set(project, collisions);
+    }
+    return collisions.get(name);
+}
+function getNamespacedPath(reflection) {
+    const path = [reflection];
+    let parent = reflection.parent;
+    while (parent?.kindOf(ReflectionKind.Namespace)) {
+        path.unshift(parent);
+        parent = parent.parent;
+    }
+    return path;
+}
+/**
+ * Returns a (hopefully) globally unique path for the given reflection.
+ *
+ * This only works for exportable symbols, so e.g. methods are not affected by this.
+ *
+ * If the given reflection has a globally unique name already, then it will be returned as is. If the name is
+ * ambiguous (i.e. there are two classes with the same name in different namespaces), then the namespaces path of the
+ * reflection will be returned.
+ */
+export function getUniquePath(reflection) {
+    if (reflection.kindOf(ReflectionKind.SomeExport)) {
+        if (getNameCollisionCount(reflection.project, reflection.name) >= 2) {
+            return getNamespacedPath(reflection);
+        }
+    }
+    return [reflection];
+}

package/dist/lib/serialization/components.d.ts

@@ -1,13 +1,10 @@
-import type { Serializer } from "./serializer";
-import type { ModelToObject } from "./schema";
+import type { Serializer } from "./serializer.js";
+import type { ModelToObject } from "./schema.js";
 /**
  * Represents Serializer plugin component.
  *
  * Like {@link Converter} plugins each {@link Serializer} plugin defines a predicate that instructs if an
  * object can be serialized by it. This is done dynamically at runtime via a `supports` method.
- *
- * Additionally, each {@link Serializer} plugin must define a predicate that instructs the group
- * it belongs to.
  */
 export interface SerializerComponent<T extends object> {
     /**

package/dist/lib/serialization/components.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/lib/serialization/deserializer.d.ts

@@ -1,8 +1,8 @@
-import type { Application } from "../application";
-import { ProjectReflection, type ReflectionVariant, type TypeKindMap } from "../models/index";
-import type { Logger } from "../utils/loggers";
-import type { JSONOutput } from "./index";
-import type { FileRegistry } from "../models/FileRegistry";
+import type { Application } from "../application.js";
+import { ProjectReflection, type ReflectionVariant, type TypeKindMap } from "../models/index.js";
+import type { Logger } from "../utils/loggers.js";
+import type { JSONOutput } from "./index.js";
+import type { FileRegistry } from "../models/FileRegistry.js";
 export interface DeserializerComponent {
     priority: number;
     supports(model: unknown, obj: unknown): boolean;
@@ -11,6 +11,12 @@ export interface DeserializerComponent {
 export interface Deserializable<T> {
     fromObject(d: Deserializer, o: T): void;
 }
+/**
+ * Deserializes TypeDoc's JSON output back to {@link Reflection} instances.
+ *
+ * @group Common
+ * @summary Deserializes TypeDoc's JSON output
+ */
 export declare class Deserializer {
     readonly application: Application;
     private deferred;
@@ -37,8 +43,16 @@ export declare class Deserializer {
      * This is generally not appropriate for merging multiple projects since projects may
      * contain reflections in their root, not inside a module.
      */
-    reviveProject(projectObj: JSONOutput.ProjectReflection, name: string, projectRoot: string, registry: FileRegistry): ProjectReflection;
-    reviveProjects(name: string, projects: readonly JSONOutput.ProjectReflection[], projectRoot: string, registry: FileRegistry): ProjectReflection;
+    reviveProject(name: string, projectObj: JSONOutput.ProjectReflection, options: {
+        projectRoot: string;
+        registry: FileRegistry;
+        addProjectDocuments?: boolean;
+    }): ProjectReflection;
+    reviveProjects(name: string, projects: readonly JSONOutput.ProjectReflection[], options: {
+        projectRoot: string;
+        registry: FileRegistry;
+        addProjectDocuments?: boolean;
+    }): ProjectReflection;
     revive<T, U extends Deserializable<T>>(source: NonNullable<T>, creator: (obj: T) => U): U;
     revive<T, U extends Deserializable<T>>(source: T | undefined, creator: (obj: T) => U): U | undefined;
     reviveMany<T, U extends Deserializable<T>>(sourceArray: T[], creator: (obj: T) => U): U[];

package/dist/lib/serialization/deserializer.js

@@ -1,125 +1,137 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Deserializer = void 0;
-const assert_1 = require("assert");
-const index_1 = require("../models/index");
-const array_1 = require("../utils/array");
-class Deserializer {
+import { ok } from "assert";
+import { ArrayType, ConditionalType, DeclarationReflection, DocumentReflection, IndexedAccessType, InferredType, IntersectionType, IntrinsicType, LiteralType, MappedType, NamedTupleMember, OptionalType, ParameterReflection, PredicateType, ProjectReflection, QueryType, ReferenceReflection, ReferenceType, Reflection, ReflectionKind, ReflectionType, RestType, SignatureReflection, TemplateLiteralType, TupleType, TypeOperatorType, TypeParameterReflection, UnionType, UnknownType, } from "../models/index.js";
+import { insertPrioritySorted } from "../utils/array.js";
+/**
+ * Deserializes TypeDoc's JSON output back to {@link Reflection} instances.
+ *
+ * @group Common
+ * @summary Deserializes TypeDoc's JSON output
+ */
+export class Deserializer {
+    application;
+    deferred = [];
+    deserializers = [];
+    activeReflection = [];
     constructor(application) {
         this.application = application;
-        this.deferred = [];
-        this.deserializers = [];
-        this.activeReflection = [];
-        this.reflectionBuilders = {
-            declaration(parent, obj) {
-                return new index_1.DeclarationReflection(obj.name, obj.kind, parent);
-            },
-            document(parent, obj) {
-                return new index_1.DocumentReflection(obj.name, parent, [], {});
-            },
-            param(parent, obj) {
-                return new index_1.ParameterReflection(obj.name, obj.kind, parent);
-            },
-            project() {
-                throw new Error("Not supported, use Deserializer.reviveProject(s) instead.");
-            },
-            reference(parent, obj) {
-                // Ugly, but we don't have a reference yet!
-                return new index_1.ReferenceReflection(obj.name, 
-                /* target */ parent, parent);
-            },
-            signature(parent, obj) {
-                return new index_1.SignatureReflection(obj.name, obj.kind, parent);
-            },
-            typeParam(parent, obj) {
-                return new index_1.TypeParameterReflection(obj.name, parent, void 0);
-            },
-        };
-        this.typeBuilders = {
-            array(obj, de) {
-                return new index_1.ArrayType(de.reviveType(obj.elementType));
-            },
-            conditional(obj, de) {
-                return new index_1.ConditionalType(de.reviveType(obj.checkType), de.reviveType(obj.extendsType), de.reviveType(obj.trueType), de.reviveType(obj.falseType));
-            },
-            indexedAccess(obj, de) {
-                return new index_1.IndexedAccessType(de.reviveType(obj.objectType), de.reviveType(obj.indexType));
-            },
-            inferred(obj, de) {
-                return new index_1.InferredType(obj.name, de.reviveType(obj.constraint));
-            },
-            intersection(obj, de) {
-                return new index_1.IntersectionType(obj.types.map((t) => de.reviveType(t)));
-            },
-            intrinsic(obj) {
-                return new index_1.IntrinsicType(obj.name);
-            },
-            literal(obj) {
-                if (obj.value && typeof obj.value === "object") {
-                    return new index_1.LiteralType(BigInt(`${obj.value.negative ? "-" : ""}${obj.value.value}`));
-                }
-                return new index_1.LiteralType(obj.value);
-            },
-            mapped(obj, de) {
-                return new index_1.MappedType(obj.parameter, de.reviveType(obj.parameterType), de.reviveType(obj.templateType), obj.readonlyModifier, obj.optionalModifier, de.reviveType(obj.nameType));
-            },
-            optional(obj, de) {
-                return new index_1.OptionalType(de.reviveType(obj.elementType));
-            },
-            predicate(obj, de) {
-                return new index_1.PredicateType(obj.name, obj.asserts, de.reviveType(obj.targetType));
-            },
-            query(obj, de) {
-                return new index_1.QueryType(de.reviveType(obj.queryType));
-            },
-            reference(obj) {
-                // Correct reference will be restored in fromObject
-                return index_1.ReferenceType.createResolvedReference(obj.name, -2, null);
-            },
-            reflection(obj, de) {
-                return new index_1.ReflectionType(de.revive(obj.declaration, (o) => de.constructReflection(o)));
-            },
-            rest(obj, de) {
-                return new index_1.RestType(de.reviveType(obj.elementType));
-            },
-            templateLiteral(obj, de) {
-                return new index_1.TemplateLiteralType(obj.head, obj.tail.map(([t, s]) => [de.reviveType(t), s]));
-            },
-            tuple(obj, de) {
-                return new index_1.TupleType(obj.elements?.map((t) => de.reviveType(t)) || []);
-            },
-            namedTupleMember(obj, de) {
-                return new index_1.NamedTupleMember(obj.name, obj.isOptional, de.reviveType(obj.element));
-            },
-            typeOperator(obj, de) {
-                return new index_1.TypeOperatorType(de.reviveType(obj.target), obj.operator);
-            },
-            union(obj, de) {
-                return new index_1.UnionType(obj.types.map((t) => de.reviveType(t)));
-            },
-            unknown(obj) {
-                return new index_1.UnknownType(obj.name);
-            },
-        };
-        this.oldIdToNewId = {};
-        this.oldFileIdToNewFileId = {};
     }
     get logger() {
         return this.application.logger;
     }
+    reflectionBuilders = {
+        declaration(parent, obj) {
+            return new DeclarationReflection(obj.name, obj.kind, parent);
+        },
+        document(parent, obj) {
+            return new DocumentReflection(obj.name, parent, [], {});
+        },
+        param(parent, obj) {
+            return new ParameterReflection(obj.name, obj.kind, parent);
+        },
+        project() {
+            throw new Error("Not supported, use Deserializer.reviveProject(s) instead.");
+        },
+        reference(parent, obj) {
+            // Ugly, but we don't have a reference yet!
+            return new ReferenceReflection(obj.name, 
+            /* target */ parent, parent);
+        },
+        signature(parent, obj) {
+            return new SignatureReflection(obj.name, obj.kind, parent);
+        },
+        typeParam(parent, obj) {
+            return new TypeParameterReflection(obj.name, parent, void 0);
+        },
+    };
+    typeBuilders = {
+        array(obj, de) {
+            return new ArrayType(de.reviveType(obj.elementType));
+        },
+        conditional(obj, de) {
+            return new ConditionalType(de.reviveType(obj.checkType), de.reviveType(obj.extendsType), de.reviveType(obj.trueType), de.reviveType(obj.falseType));
+        },
+        indexedAccess(obj, de) {
+            return new IndexedAccessType(de.reviveType(obj.objectType), de.reviveType(obj.indexType));
+        },
+        inferred(obj, de) {
+            return new InferredType(obj.name, de.reviveType(obj.constraint));
+        },
+        intersection(obj, de) {
+            return new IntersectionType(obj.types.map((t) => de.reviveType(t)));
+        },
+        intrinsic(obj) {
+            return new IntrinsicType(obj.name);
+        },
+        literal(obj) {
+            if (obj.value && typeof obj.value === "object") {
+                return new LiteralType(BigInt(`${obj.value.negative ? "-" : ""}${obj.value.value}`));
+            }
+            return new LiteralType(obj.value);
+        },
+        mapped(obj, de) {
+            return new MappedType(obj.parameter, de.reviveType(obj.parameterType), de.reviveType(obj.templateType), obj.readonlyModifier, obj.optionalModifier, de.reviveType(obj.nameType));
+        },
+        optional(obj, de) {
+            return new OptionalType(de.reviveType(obj.elementType));
+        },
+        predicate(obj, de) {
+            return new PredicateType(obj.name, obj.asserts, de.reviveType(obj.targetType));
+        },
+        query(obj, de) {
+            return new QueryType(de.reviveType(obj.queryType));
+        },
+        reference(obj) {
+            // Correct reference will be restored in fromObject
+            return ReferenceType.createResolvedReference(obj.name, -2, null);
+        },
+        reflection(obj, de) {
+            return new ReflectionType(de.revive(obj.declaration, (o) => de.constructReflection(o)));
+        },
+        rest(obj, de) {
+            return new RestType(de.reviveType(obj.elementType));
+        },
+        templateLiteral(obj, de) {
+            return new TemplateLiteralType(obj.head, obj.tail.map(([t, s]) => [de.reviveType(t), s]));
+        },
+        tuple(obj, de) {
+            return new TupleType(obj.elements?.map((t) => de.reviveType(t)) || []);
+        },
+        namedTupleMember(obj, de) {
+            return new NamedTupleMember(obj.name, obj.isOptional, de.reviveType(obj.element));
+        },
+        typeOperator(obj, de) {
+            return new TypeOperatorType(de.reviveType(obj.target), obj.operator);
+        },
+        union(obj, de) {
+            return new UnionType(obj.types.map((t) => de.reviveType(t)));
+        },
+        unknown(obj) {
+            return new UnknownType(obj.name);
+        },
+    };
+    /**
+     * Only set when deserializing.
+     */
+    projectRoot;
+    oldIdToNewId = {};
+    oldFileIdToNewFileId = {};
+    project;
     addDeserializer(de) {
-        (0, array_1.insertPrioritySorted)(this.deserializers, de);
+        insertPrioritySorted(this.deserializers, de);
     }
     /**
      * Revive a single project into the structure it was originally created with.
      * This is generally not appropriate for merging multiple projects since projects may
      * contain reflections in their root, not inside a module.
      */
-    reviveProject(projectObj, name, projectRoot, registry) {
-        (0, assert_1.ok)(this.deferred.length === 0, "Deserializer.defer was called when not deserializing");
-        const project = new index_1.ProjectReflection(name || projectObj.name, registry);
+    reviveProject(name, projectObj, options) {
+        ok(this.deferred.length === 0, "Deserializer.defer was called when not deserializing");
+        const project = new ProjectReflection(name || projectObj.name, options.registry);
+        if (options.addProjectDocuments) {
+            this.application.converter.addProjectDocuments(project);
+        }
         this.project = project;
-        this.projectRoot = projectRoot;
+        this.projectRoot = options.projectRoot;
         this.oldIdToNewId = { [projectObj.id]: project.id };
         this.oldFileIdToNewFileId = {};
         this.fromObject(project, projectObj);
@@ -128,24 +140,28 @@ class Deserializer {
         for (const def of deferred) {
             def(project);
         }
-        (0, assert_1.ok)(this.deferred.length === 0, "Work may not be double deferred when deserializing.");
-        (0, assert_1.ok)(this.activeReflection.length === 0, "Imbalanced reflection deserialization");
+        ok(this.deferred.length === 0, "Work may not be double deferred when deserializing.");
+        ok(this.activeReflection.length === 0, "Imbalanced reflection deserialization");
         this.project = undefined;
         this.projectRoot = undefined;
         this.oldIdToNewId = {};
         this.oldFileIdToNewFileId = {};
         return project;
     }
-    reviveProjects(name, projects, projectRoot, registry) {
-        if (projects.length === 1) {
-            return this.reviveProject(projects[0], name, projectRoot, registry);
+    reviveProjects(name, projects, options) {
+        if (projects.length === 1 &&
+            !this.application.options.getValue("alwaysCreateEntryPointModule")) {
+            return this.reviveProject(name, projects[0], options);
+        }
+        const project = new ProjectReflection(name, options.registry);
+        if (options.addProjectDocuments) {
+            this.application.converter.addProjectDocuments(project);
         }
-        const project = new index_1.ProjectReflection(name, registry);
         this.project = project;
-        this.projectRoot = projectRoot;
+        this.projectRoot = options.projectRoot;
         for (const proj of projects) {
-            (0, assert_1.ok)(this.deferred.length === 0, "Deserializer.defer was called when not deserializing");
-            const projModule = new index_1.DeclarationReflection(proj.name, index_1.ReflectionKind.Module, project);
+            ok(this.deferred.length === 0, "Deserializer.defer was called when not deserializing");
+            const projModule = new DeclarationReflection(proj.name, ReflectionKind.Module, project);
             project.registerReflection(projModule, undefined, undefined);
             project.addChild(projModule);
             this.oldIdToNewId = { [proj.id]: projModule.id };
@@ -156,8 +172,8 @@ class Deserializer {
             for (const def of deferred) {
                 def(project);
             }
-            (0, assert_1.ok)(this.deferred.length === 0, "Work may not be double deferred when deserializing.");
-            (0, assert_1.ok)(this.activeReflection.length === 0, "Imbalanced reflection deserialization");
+            ok(this.deferred.length === 0, "Work may not be double deferred when deserializing.");
+            ok(this.activeReflection.length === 0, "Imbalanced reflection deserialization");
         }
         this.oldIdToNewId = {};
         this.oldFileIdToNewFileId = {};
@@ -185,7 +201,7 @@ class Deserializer {
         return this.revive(obj, (o) => this.constructType(o));
     }
     constructReflection(obj) {
-        (0, assert_1.ok)(this.activeReflection.length > 0);
+        ok(this.activeReflection.length > 0);
         const result = this.reflectionBuilders[obj.variant](this.activeReflection[this.activeReflection.length - 1], obj);
         this.oldIdToNewId[obj.id] = result.id;
         this.project.registerReflection(result, undefined, undefined);
@@ -196,7 +212,7 @@ class Deserializer {
         return result;
     }
     fromObject(receiver, obj) {
-        if (receiver instanceof index_1.Reflection) {
+        if (receiver instanceof Reflection) {
             this.activeReflection.push(receiver);
         }
         receiver.fromObject(this, obj);
@@ -205,7 +221,7 @@ class Deserializer {
                 de.fromObject(receiver, obj);
             }
         }
-        if (receiver instanceof index_1.Reflection) {
+        if (receiver instanceof Reflection) {
             this.activeReflection.pop();
         }
     }
@@ -219,4 +235,3 @@ class Deserializer {
         this.deferred.push(cb);
     }
 }
-exports.Deserializer = Deserializer;

package/dist/lib/serialization/events.d.ts

@@ -1,5 +1,5 @@
-import type { ProjectReflection } from "../models";
-import type { ProjectReflection as JSONProjectReflection } from "./schema";
+import type { ProjectReflection } from "../models/index.js";
+import type { ProjectReflection as JSONProjectReflection } from "./schema.js";
 /**
  * An event emitted by the {@link Serializer} class at the very beginning and
  * ending of the a project serialization process.

package/dist/lib/serialization/events.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SerializeEvent = void 0;
 /**
  * An event emitted by the {@link Serializer} class at the very beginning and
  * ending of the a project serialization process.
@@ -8,10 +5,14 @@ exports.SerializeEvent = void 0;
  * @see {@link Serializer.EVENT_BEGIN}
  * @see {@link Serializer.EVENT_END}
  */
-class SerializeEvent {
+export class SerializeEvent {
+    /**
+     * The project the renderer is currently processing.
+     */
+    project;
+    output;
     constructor(project, output) {
         this.project = project;
         this.output = output;
     }
 }
-exports.SerializeEvent = SerializeEvent;