typedoc 0.28.2 → 0.28.4

package/dist/browser-locales/de.d.ts

@@ -0,0 +1,2 @@
+const translations: Record<string, string>;
+export default translations;

package/dist/browser-locales/de.js

@@ -0,0 +1,62 @@
+export default {
+    "serialized_project_referenced_0_not_part_of_project": "Serialisiertes Projekt referenziert Reflection {0}, welche kein Teil des Projekts ist",
+    "kind_project": "Projekt",
+    "kind_module": "Modul",
+    "kind_namespace": "Namensraum",
+    "kind_enum": "Aufzählung",
+    "kind_enum_member": "Aufzählungselement",
+    "kind_variable": "Variable",
+    "kind_function": "Funktion",
+    "kind_class": "Klasse",
+    "kind_interface": "Schnittstelle",
+    "kind_constructor": "Konstruktor",
+    "kind_property": "Eigenschaft",
+    "kind_method": "Methode",
+    "kind_call_signature": "Aufrufsignatur",
+    "kind_index_signature": "Indexsignatur",
+    "kind_constructor_signature": "Konstruktorsignatur",
+    "kind_parameter": "Parameter",
+    "kind_type_literal": "Typenliteral",
+    "kind_type_parameter": "Typenparameter",
+    "kind_accessor": "Zugriffsfunktion",
+    "kind_get_signature": "Abfragesignatur",
+    "kind_set_signature": "Änderungssignatur",
+    "kind_type_alias": "Typenalias",
+    "kind_reference": "Referenz",
+    "kind_document": "Dokument",
+    "kind_plural_project": "Projekte",
+    "kind_plural_module": "Module",
+    "kind_plural_namespace": "Namensräume",
+    "kind_plural_enum": "Aufzählungen",
+    "kind_plural_enum_member": "Aufzählungselemente",
+    "kind_plural_variable": "Variablen",
+    "kind_plural_function": "Funktionen",
+    "kind_plural_class": "Klassen",
+    "kind_plural_interface": "Schnittstellen",
+    "kind_plural_constructor": "Konstruktoren",
+    "kind_plural_property": "Eigenschaften",
+    "kind_plural_method": "Methoden",
+    "kind_plural_call_signature": "Aufrufsignaturen",
+    "kind_plural_index_signature": "Indexsignaturen",
+    "kind_plural_constructor_signature": "Konstruktorsignaturen",
+    "kind_plural_parameter": "Parameter",
+    "kind_plural_type_literal": "Typenliterale",
+    "kind_plural_type_parameter": "Typenparameter",
+    "kind_plural_accessor": "Zugriffsfunktionen",
+    "kind_plural_get_signature": "Abfragesignaturen",
+    "kind_plural_set_signature": "Änderungssignaturen",
+    "kind_plural_type_alias": "Typenaliasse",
+    "kind_plural_reference": "Referenzen",
+    "kind_plural_document": "Dokumente",
+    "flag_private": "Privat",
+    "flag_protected": "Geschützt",
+    "flag_public": "Öffentlich",
+    "flag_static": "Statisch",
+    "flag_external": "Extern",
+    "flag_optional": "Optional",
+    "flag_rest": "Rest",
+    "flag_abstract": "Abstrakt",
+    "flag_const": "Konstant",
+    "flag_readonly": "Schreibgeschützt",
+    "flag_inherited": "Geerbt"
+}

package/dist/lib/cli.js

@@ -20,7 +20,7 @@ async function main() {
             new td.TypeDocReader(),
             new td.PackageJsonReader(),
             new td.TSConfigReader(),
-            new td.ArgumentsReader(300),
+            new td.ArgumentsReader(300).ignoreErrors(),
         ]);
         const exitCode = await run(app);
         if (exitCode !== ExitCodes.Watching) {

package/dist/lib/converter/context.js

@@ -145,7 +145,7 @@ export class Context {
             reflection.escapedName = symbol?.escapedName ? String(symbol.escapedName) : undefined;
             this.addChild(reflection);
         }
-        if (symbol && this.converter.isExternal(symbol)) {
+        if (symbol && this.converter.isExternal(symbol, this.checker)) {
             reflection.setFlag(ReflectionFlag.External);
         }
         if (exportSymbol) {
@@ -188,7 +188,7 @@ export class Context {
         }
     }
     shouldIgnore(symbol) {
-        return this.converter.shouldIgnore(symbol);
+        return this.converter.shouldIgnore(symbol, this.checker);
     }
     /**
      * Register a newly generated reflection. All created reflections should be

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

@@ -226,10 +226,10 @@ export declare class Converter extends AbstractComponent<Application, ConverterE
      * information at this point since comment discovery hasn't happened.
      * @internal
      */
-    shouldIgnore(symbol: ts.Symbol): boolean;
+    shouldIgnore(symbol: ts.Symbol, checker: ts.TypeChecker): boolean;
     private isExcluded;
     /** @internal */
-    isExternal(symbol: ts.Symbol): boolean;
+    isExternal(symbol: ts.Symbol, checker: ts.TypeChecker): boolean;
     processDocumentTags(reflection: Reflection, parent: ContainerReflection): void;
     private addDocument;
     private _buildCommentParserConfig;

package/dist/lib/converter/converter.js

@@ -59,6 +59,7 @@ import { SourcePlugin } from "./plugins/SourcePlugin.js";
 import { TypePlugin } from "./plugins/TypePlugin.js";
 import { IncludePlugin } from "./plugins/IncludePlugin.js";
 import { MergeModuleWithPlugin } from "./plugins/MergeModuleWithPlugin.js";
+import { resolveAliasedSymbol } from "./utils/symbols.js";
 /**
  * Compiles source files using TypeScript and converts compiler symbols to reflections.
  *
@@ -310,7 +311,12 @@ let Converter = (() => {
             this.compile(entryPoints, context);
             this.resolve(context);
             this.trigger(Converter.EVENT_END, context);
-            this._config = undefined;
+            // Delete caches of options so that test usage which changes options
+            // doesn't have confusing behavior where tests run in isolation work
+            // but break when run as a batch.
+            delete this._config;
+            delete this.excludeCache;
+            delete this.externalPatternCache;
             return project;
         }
         /** @internal */
@@ -487,11 +493,12 @@ let Converter = (() => {
          * information at this point since comment discovery hasn't happened.
          * @internal
          */
-        shouldIgnore(symbol) {
+        shouldIgnore(symbol, checker) {
+            symbol = resolveAliasedSymbol(symbol, checker);
             if (this.isExcluded(symbol)) {
                 return true;
             }
-            return this.excludeExternals && this.isExternal(symbol);
+            return this.excludeExternals && this.isExternal(symbol, checker);
         }
         isExcluded(symbol) {
             this.excludeCache ??= new MinimatchSet(this.application.options.getValue("exclude"));
@@ -499,10 +506,10 @@ let Converter = (() => {
             return (symbol.getDeclarations() ?? []).some((node) => cache.matchesAny(node.getSourceFile().fileName));
         }
         /** @internal */
-        isExternal(symbol) {
+        isExternal(symbol, checker) {
             this.externalPatternCache ??= new MinimatchSet(this.externalPattern);
             const cache = this.externalPatternCache;
-            const declarations = symbol.getDeclarations();
+            const declarations = resolveAliasedSymbol(symbol, checker).getDeclarations();
             // `undefined` has no declarations, if someone does `export default undefined`
             // the symbol ends up as having no declarations (the export symbol does, but
             // not the source symbol)

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

@@ -133,6 +133,18 @@ export class ImplementsPlugin extends ConverterComponent {
                 }
             });
         }
+        // Remove hidden classes/interfaces which we inherit from
+        if (reflection.kindOf(ReflectionKind.ClassOrInterface)) {
+            const notHiddenType = (t) => !(t instanceof ReferenceType) ||
+                !t.symbolId ||
+                !project.symbolIdHasBeenRemoved(t.symbolId);
+            reflection.implementedTypes = reflection.implementedTypes?.filter(notHiddenType);
+            if (!reflection.implementedTypes?.length)
+                delete reflection.implementedTypes;
+            reflection.extendedTypes = reflection.extendedTypes?.filter(notHiddenType);
+            if (!reflection.extendedTypes?.length)
+                delete reflection.extendedTypes;
+        }
         if (reflection.kindOf(ReflectionKind.ClassOrInterface) &&
             reflection.extendedTypes) {
             this.analyzeInheritance(project, reflection);

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

@@ -246,3 +246,5 @@ regionTagREsByExt["php"] = regionTagREsByExt["cs"];
 regionTagREsByExt["ps1"] = regionTagREsByExt["cs"];
 regionTagREsByExt["py"] = regionTagREsByExt["cs"];
 regionTagREsByExt["js"] = regionTagREsByExt["ts"];
+regionTagREsByExt["mts"] = regionTagREsByExt["ts"];
+regionTagREsByExt["cts"] = regionTagREsByExt["ts"];

package/dist/lib/converter/symbols.js

@@ -8,6 +8,7 @@ import { convertTypeParameters, createConstructSignatureWithType, createSignatur
 import { convertJsDocAlias, convertJsDocCallback } from "./jsdoc.js";
 import { getHeritageTypes } from "./utils/nodes.js";
 import { removeUndefined } from "./utils/reflections.js";
+import { resolveAliasedSymbol } from "./utils/symbols.js";
 const symbolConverters = {
     [ts.SymbolFlags.RegularEnum]: convertEnum,
     [ts.SymbolFlags.ConstEnum]: convertEnum,
@@ -61,7 +62,7 @@ for (const key of Object.keys(symbolConverters)) {
 }
 assert(conversionOrder.reduce((a, b) => a | b, 0) === allConverterFlags, "conversionOrder contains a symbol flag that converters do not.");
 function _convertSymbolNow(context, symbol, exportSymbol) {
-    if (context.shouldIgnore(symbol)) {
+    if (context.shouldIgnore(resolveAliasedSymbol(symbol, context.checker))) {
         return;
     }
     // This check can catch symbols which ought to be documented as references

package/dist/lib/converter/types.js

@@ -45,6 +45,7 @@ export function loadConverters() {
         // Only used if skipLibCheck: true
         jsDocNullableTypeConverter,
         jsDocNonNullableTypeConverter,
+        jsDocAllTypeConverter,
     ]) {
         for (const key of actor.kind) {
             if (key === undefined) {
@@ -718,6 +719,14 @@ const jsDocNonNullableTypeConverter = {
     // Should be a UnionType
     convertType: requestBugReport,
 };
+const jsDocAllTypeConverter = {
+    kind: [ts.SyntaxKind.JSDocAllType],
+    convert() {
+        return new IntrinsicType("any");
+    },
+    // Should be a UnionType
+    convertType: requestBugReport,
+};
 function requestBugReport(context, nodeOrType) {
     if ("kind" in nodeOrType) {
         const kindName = ts.SyntaxKind[nodeOrType.kind];
@@ -795,5 +804,11 @@ function convertTypeInlined(context, type) {
         const elementType = convertType(context, context.checker.getTypeArguments(type)[0]);
         return new ArrayType(elementType);
     }
+    if (isTypeReference(type) && context.checker.isTupleType(type)) {
+        const tupleNode = context.checker.typeToTypeNode(type.target, void 0, ts.NodeBuilderFlags.IgnoreErrors);
+        if (ts.isTupleTypeNode(tupleNode)) {
+            return tupleConverter.convertType(context, type, tupleNode);
+        }
+    }
     return typeLiteralConverter.convertType(context, type);
 }