@depup/typedoc 0.28.17-depup.0

package/dist/lib/converter/factories/index-signature.d.ts

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

package/dist/lib/converter/factories/index-signature.js

@@ -0,0 +1,50 @@
+import assert from "assert";
+import { DeclarationReflection, ParameterReflection, ReflectionFlag, ReflectionKind, SignatureReflection, UnionType, } from "../../models/index.js";
+import { ConverterEvents } from "../converter-events.js";
+export function convertIndexSignatures(context, type) {
+    assert(context.scope instanceof DeclarationReflection);
+    // Each declaration should have one SignatureReflection
+    // If we don't have a declaration, the index signature was inferred by TS
+    // and we should make a separate SignatureReflection for each index signature.
+    const seenByDeclaration = new Map();
+    const createdSignatures = [];
+    for (const indexInfo of context.checker.getIndexInfosOfType(type)) {
+        // Check if we've already created an index signature for this type
+        if (indexInfo.declaration &&
+            seenByDeclaration.has(indexInfo.declaration)) {
+            const createdSig = seenByDeclaration.get(indexInfo.declaration);
+            if (createdSig.parameters[0].type?.type !== "union") {
+                createdSig.parameters[0].type = new UnionType([
+                    createdSig.parameters[0].type,
+                ]);
+            }
+            createdSig.parameters[0].type.types.push(context.converter.convertType(context.withScope(createdSig), indexInfo.keyType));
+            // No need to update the return type as it will be the same for all members.
+            continue;
+        }
+        // Otherwise create a new one
+        const index = new SignatureReflection("__index", ReflectionKind.IndexSignature, context.scope);
+        const ic = context.withScope(index);
+        if (indexInfo.isReadonly) {
+            index.setFlag(ReflectionFlag.Readonly);
+        }
+        createdSignatures.push([indexInfo.declaration, index]);
+        if (indexInfo.declaration) {
+            seenByDeclaration.set(indexInfo.declaration, index);
+            index.comment = context.getNodeComment(indexInfo.declaration, 
+            /* moduleComment */ false);
+        }
+        index.parameters = [
+            new ParameterReflection(indexInfo.declaration?.parameters[0].name.getText() ?? "key", ReflectionKind.Parameter, index),
+        ];
+        index.parameters[0].type = context.converter.convertType(ic.withScope(index.parameters[0]), indexInfo.keyType);
+        index.type = context.converter.convertType(ic, indexInfo.type);
+        context.registerReflection(index, indexInfo.declaration?.symbol);
+        context.scope.indexSignatures ||= [];
+        context.scope.indexSignatures.push(index);
+    }
+    // Now that we've created everything, trigger events for them.
+    for (const [declaration, index] of createdSignatures) {
+        context.converter.trigger(ConverterEvents.CREATE_SIGNATURE, context, index, declaration);
+    }
+}

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

@@ -0,0 +1,14 @@
+import ts from "typescript";
+import { ParameterReflection, type Reflection, ReflectionKind, SignatureReflection, TypeParameterReflection } from "../../models/index.js";
+import type { Context } from "../context.js";
+export declare function convertConstructSignatures(context: Context, symbol: ts.Symbol): void;
+export declare function createSignature(context: Context, kind: ReflectionKind.CallSignature | ReflectionKind.ConstructorSignature | ReflectionKind.GetSignature | ReflectionKind.SetSignature, signature: ts.Signature, symbol: ts.Symbol | undefined, declaration?: ts.SignatureDeclaration | ts.JSDocSignature): void;
+/**
+ * Special cased constructor factory for functions tagged with `@class`
+ */
+export declare function createConstructSignatureWithType(context: Context, signature: ts.Signature, classType: Reflection): void;
+export declare function convertParameterNodes(context: Context, sigRef: SignatureReflection, parameters: readonly (ts.JSDocParameterTag | ts.ParameterDeclaration)[]): ParameterReflection[];
+export declare function convertTypeParameters(context: Context, parent: Reflection, parameters: readonly ts.TypeParameter[] | undefined): TypeParameterReflection[] | undefined;
+export declare function convertTypeParameterNodes(context: Context, parameters: readonly ts.TypeParameterDeclaration[] | undefined): TypeParameterReflection[] | undefined;
+export declare function createTypeParamReflection(param: ts.TypeParameterDeclaration, context: Context): TypeParameterReflection;
+export declare function convertTemplateParameterNodes(context: Context, nodes: readonly ts.JSDocTemplateTag[] | undefined): TypeParameterReflection[] | undefined;

package/dist/lib/converter/factories/signature.js

@@ -0,0 +1,353 @@
+import ts from "typescript";
+import assert from "assert";
+import { DeclarationReflection, IntrinsicType, ParameterReflection, PredicateType, ReferenceType, ReflectionFlag, ReflectionKind, SignatureReflection, TypeParameterReflection, VarianceModifier, } from "../../models/index.js";
+import { ConverterEvents } from "../converter-events.js";
+import { convertDefaultValue } from "../convert-expression.js";
+import { removeUndefined } from "../utils/reflections.js";
+export function convertConstructSignatures(context, symbol) {
+    const type = context.checker.getDeclaredTypeOfSymbol(symbol);
+    // These get added as a "constructor" member of this interface. This is a problem... but nobody
+    // has complained yet. We really ought to have a constructSignatures property on the reflection instead.
+    const constructSignatures = context.checker.getSignaturesOfType(type, ts.SignatureKind.Construct);
+    if (constructSignatures.length) {
+        const constructMember = new DeclarationReflection("constructor", ReflectionKind.Constructor, context.scope);
+        context.postReflectionCreation(constructMember, symbol, void 0);
+        context.finalizeDeclarationReflection(constructMember);
+        const constructContext = context.withScope(constructMember);
+        constructSignatures.forEach((sig) => createSignature(constructContext, ReflectionKind.ConstructorSignature, sig, symbol));
+    }
+}
+export function createSignature(context, kind, signature, symbol, declaration) {
+    assert(context.scope instanceof DeclarationReflection);
+    declaration ||= signature.getDeclaration();
+    const sigRef = new SignatureReflection(kind == ReflectionKind.ConstructorSignature
+        ? context.scope.parent.name
+        : context.scope.name, kind, context.scope);
+    // This feels awful, but we need some way to tell if callable signatures on classes
+    // are "static" (e.g. `Foo()`) or not (e.g. `(new Foo())()`)
+    if (context.shouldBeStatic) {
+        sigRef.setFlag(ReflectionFlag.Static);
+    }
+    if (symbol && declaration) {
+        context.project.registerSymbolId(sigRef, context.createSymbolId(symbol, declaration));
+    }
+    let parentReflection = context.scope;
+    if (parentReflection.kindOf(ReflectionKind.TypeLiteral) &&
+        parentReflection.parent instanceof DeclarationReflection) {
+        parentReflection = parentReflection.parent;
+    }
+    if (declaration) {
+        const sigComment = context.getSignatureComment(declaration);
+        if (parentReflection.comment?.discoveryId !== sigComment?.discoveryId) {
+            sigRef.comment = sigComment;
+            if (parentReflection.kindOf(ReflectionKind.MayContainDocuments)) {
+                context.converter.processDocumentTags(sigRef, parentReflection);
+            }
+        }
+    }
+    const sigRefCtx = context.withScope(sigRef);
+    sigRef.typeParameters = convertTypeParameters(sigRefCtx, sigRef, signature.typeParameters);
+    const parameterSymbols = signature.thisParameter
+        ? [signature.thisParameter, ...signature.parameters]
+        : signature.parameters;
+    sigRef.parameters = convertParameters(sigRefCtx, sigRef, parameterSymbols, declaration?.parameters);
+    const predicate = context.checker.getTypePredicateOfSignature(signature);
+    if (predicate) {
+        sigRef.type = convertPredicate(predicate, sigRefCtx);
+    }
+    else if (kind == ReflectionKind.SetSignature) {
+        sigRef.type = new IntrinsicType("void");
+    }
+    else if (declaration?.type?.kind === ts.SyntaxKind.ThisType) {
+        sigRef.type = new IntrinsicType("this");
+    }
+    else {
+        let typeNode = declaration?.type;
+        if (typeNode && ts.isJSDocReturnTag(typeNode)) {
+            typeNode = typeNode.typeExpression?.type;
+        }
+        sigRef.type = context.converter.convertType(sigRefCtx, signature.getReturnType(), typeNode);
+    }
+    context.registerReflection(sigRef, undefined);
+    switch (kind) {
+        case ReflectionKind.GetSignature:
+            context.scope.getSignature = sigRef;
+            break;
+        case ReflectionKind.SetSignature:
+            context.scope.setSignature = sigRef;
+            break;
+        case ReflectionKind.CallSignature:
+        case ReflectionKind.ConstructorSignature:
+            context.scope.signatures ??= [];
+            context.scope.signatures.push(sigRef);
+            break;
+    }
+    context.converter.trigger(ConverterEvents.CREATE_SIGNATURE, context, sigRef, declaration, signature);
+}
+/**
+ * Special cased constructor factory for functions tagged with `@class`
+ */
+export function createConstructSignatureWithType(context, signature, classType) {
+    assert(context.scope instanceof DeclarationReflection);
+    const declaration = signature.getDeclaration();
+    const sigRef = new SignatureReflection(context.scope.parent.name, ReflectionKind.ConstructorSignature, context.scope);
+    const sigRefCtx = context.withScope(sigRef);
+    if (declaration) {
+        sigRef.comment = context.getSignatureComment(declaration);
+        if (sigRef.comment?.discoveryId === context.scope.parent?.comment?.discoveryId) {
+            delete sigRef.comment;
+        }
+    }
+    const parameterSymbols = signature.thisParameter
+        ? [signature.thisParameter, ...signature.parameters]
+        : [...signature.parameters];
+    // Prevent a `this` parameter from appearing on constructor signature
+    // as TS disallows them on regular classes.
+    if (parameterSymbols[0]?.name === "this") {
+        parameterSymbols.shift();
+    }
+    sigRef.parameters = convertParameters(sigRefCtx, sigRef, parameterSymbols, declaration?.parameters);
+    sigRef.parameters = convertParameters(sigRefCtx, sigRef, parameterSymbols, undefined);
+    // Do NOT convert type parameters here, they go on the class itself in the @class case
+    // See #2914.
+    sigRef.type = ReferenceType.createResolvedReference(context.scope.parent.name, classType, context.project);
+    context.registerReflection(sigRef, undefined);
+    context.scope.signatures ??= [];
+    context.scope.signatures.push(sigRef);
+    context.converter.trigger(ConverterEvents.CREATE_SIGNATURE, context, sigRef, declaration, signature);
+}
+function convertParameters(context, sigRef, parameters, parameterNodes) {
+    // #2698 if `satisfies` is used to imply a this parameter, we might have
+    // more parameters than parameter nodes and need to shift the parameterNode
+    // access index. Very ugly, but it does the job.
+    const parameterNodeOffset = parameterNodes?.length !== parameters.length ? -1 : 0;
+    return parameters.map((param, i) => {
+        const declaration = param.valueDeclaration;
+        assert(!declaration ||
+            ts.isParameter(declaration) ||
+            ts.isJSDocParameterTag(declaration));
+        const paramRefl = new ParameterReflection(/^__\d+$/.test(param.name) ? "__namedParameters" : param.name, ReflectionKind.Parameter, sigRef);
+        if (declaration && ts.isJSDocParameterTag(declaration)) {
+            paramRefl.comment = context.getJsDocComment(declaration);
+        }
+        paramRefl.comment ||= context.getComment(param, paramRefl.kind);
+        context.registerReflection(paramRefl, param);
+        context.converter.trigger(ConverterEvents.CREATE_PARAMETER, context, paramRefl);
+        let type;
+        let typeNode;
+        if (declaration) {
+            type = context.checker.getTypeOfSymbolAtLocation(param, declaration);
+            if (ts.isParameter(declaration)) {
+                typeNode = declaration.type;
+            }
+            else {
+                typeNode = declaration.typeExpression?.type;
+            }
+        }
+        else {
+            type = context.checker.getTypeOfSymbol(param);
+        }
+        if (declaration &&
+            ts.isParameter(declaration) &&
+            declaration.type?.kind === ts.SyntaxKind.ThisType) {
+            paramRefl.type = new IntrinsicType("this");
+        }
+        else if (!type) {
+            paramRefl.type = new IntrinsicType("any");
+        }
+        else {
+            paramRefl.type = context.converter.convertType(context.withScope(paramRefl), type, typeNode);
+        }
+        let isOptional = false;
+        if (declaration) {
+            isOptional = ts.isParameter(declaration)
+                ? !!declaration.questionToken ||
+                    ts
+                        .getJSDocParameterTags(declaration)
+                        .some((tag) => tag.isBracketed)
+                : declaration.isBracketed;
+        }
+        if (isOptional) {
+            paramRefl.type = removeUndefined(paramRefl.type);
+        }
+        paramRefl.defaultValue = convertDefaultValue(parameterNodes?.[i + parameterNodeOffset]);
+        paramRefl.setFlag(ReflectionFlag.Optional, isOptional);
+        // If we have no declaration, then this is an implicitly defined parameter in JS land
+        // because the method body uses `arguments`... which is always a rest argument,
+        // unless it is a this parameter defined with @this in JSDoc.
+        let isRest = param.name !== "this";
+        if (declaration) {
+            isRest = ts.isParameter(declaration)
+                ? !!declaration.dotDotDotToken
+                : !!declaration.typeExpression &&
+                    ts.isJSDocVariadicType(declaration.typeExpression.type);
+        }
+        paramRefl.setFlag(ReflectionFlag.Rest, isRest);
+        checkForDestructuredParameterDefaults(paramRefl, parameterNodes?.[i + parameterNodeOffset]);
+        return paramRefl;
+    });
+}
+export function convertParameterNodes(context, sigRef, parameters) {
+    return parameters.map((param) => {
+        const paramRefl = new ParameterReflection(/__\d+/.test(param.name.getText())
+            ? "__namedParameters"
+            : param.name.getText(), ReflectionKind.Parameter, sigRef);
+        if (ts.isJSDocParameterTag(param)) {
+            paramRefl.comment = context.getJsDocComment(param);
+        }
+        context.registerReflection(paramRefl, context.getSymbolAtLocation(param));
+        context.converter.trigger(ConverterEvents.CREATE_PARAMETER, context, paramRefl);
+        paramRefl.type = context.converter.convertType(context.withScope(paramRefl), ts.isParameter(param) ? param.type : param.typeExpression?.type);
+        const isOptional = ts.isParameter(param)
+            ? !!param.questionToken
+            : param.isBracketed;
+        if (isOptional) {
+            paramRefl.type = removeUndefined(paramRefl.type);
+        }
+        paramRefl.defaultValue = convertDefaultValue(param);
+        paramRefl.setFlag(ReflectionFlag.Optional, isOptional);
+        paramRefl.setFlag(ReflectionFlag.Rest, ts.isParameter(param)
+            ? !!param.dotDotDotToken
+            : !!param.typeExpression &&
+                ts.isJSDocVariadicType(param.typeExpression.type));
+        checkForDestructuredParameterDefaults(paramRefl, param);
+        return paramRefl;
+    });
+}
+function checkForDestructuredParameterDefaults(param, decl) {
+    if (!decl || !ts.isParameter(decl))
+        return;
+    if (param.name !== "__namedParameters")
+        return;
+    if (!ts.isObjectBindingPattern(decl.name))
+        return;
+    if (param.type?.type !== "reflection")
+        return;
+    for (const child of param.type.declaration.children || []) {
+        const tsChild = decl.name.elements.find((el) => (el.propertyName || el.name).getText() === child.name);
+        if (tsChild) {
+            child.defaultValue = convertDefaultValue(tsChild);
+        }
+    }
+}
+export function convertTypeParameters(context, parent, parameters) {
+    return parameters?.map((param) => {
+        const constraintT = param.getConstraint();
+        const defaultT = param.getDefault();
+        // There's no way to determine directly from a ts.TypeParameter what it's variance modifiers are
+        // so unfortunately we have to go back to the node for this...
+        const declaration = param
+            .getSymbol()
+            ?.declarations?.find(ts.isTypeParameterDeclaration);
+        const variance = getVariance(declaration?.modifiers);
+        const paramRefl = new TypeParameterReflection(param.symbol.name, parent, variance);
+        const paramCtx = context.withScope(paramRefl);
+        paramRefl.type = constraintT
+            ? context.converter.convertType(paramCtx, constraintT)
+            : void 0;
+        paramRefl.default = defaultT
+            ? context.converter.convertType(paramCtx, defaultT)
+            : void 0;
+        // No way to determine this from the type parameter itself, need to go back to the declaration
+        if (declaration?.modifiers?.some((m) => m.kind === ts.SyntaxKind.ConstKeyword)) {
+            paramRefl.flags.setFlag(ReflectionFlag.Const, true);
+        }
+        context.registerReflection(paramRefl, param.getSymbol());
+        context.converter.trigger(ConverterEvents.CREATE_TYPE_PARAMETER, context, paramRefl);
+        return paramRefl;
+    });
+}
+export function convertTypeParameterNodes(context, parameters) {
+    return parameters?.map((param) => createTypeParamReflection(param, context));
+}
+export function createTypeParamReflection(param, context) {
+    const paramRefl = new TypeParameterReflection(param.name.text, context.scope, getVariance(param.modifiers));
+    const paramScope = context.withScope(paramRefl);
+    if (ts.isJSDocTemplateTag(param.parent)) {
+        // With a @template tag, the constraint applies only to the
+        // first type parameter declared.
+        if (param.parent.typeParameters[0].name.text === param.name.text && param.parent.constraint) {
+            paramRefl.type = context.converter.convertType(paramScope, param.parent.constraint);
+        }
+    }
+    else {
+        paramRefl.type = param.constraint
+            ? context.converter.convertType(paramScope, param.constraint)
+            : void 0;
+    }
+    paramRefl.default = param.default
+        ? context.converter.convertType(paramScope, param.default)
+        : void 0;
+    if (param.modifiers?.some((m) => m.kind === ts.SyntaxKind.ConstKeyword)) {
+        paramRefl.flags.setFlag(ReflectionFlag.Const, true);
+    }
+    context.registerReflection(paramRefl, param.symbol);
+    if (ts.isJSDocTemplateTag(param.parent)) {
+        paramRefl.comment = context.getJsDocComment(param.parent);
+    }
+    context.converter.trigger(ConverterEvents.CREATE_TYPE_PARAMETER, context, paramRefl, param);
+    return paramRefl;
+}
+export function convertTemplateParameterNodes(context, nodes) {
+    return nodes?.flatMap((node) => {
+        return node.typeParameters.map((param, index) => {
+            const paramRefl = new TypeParameterReflection(param.name.text, context.scope, getVariance(param.modifiers));
+            const paramScope = context.withScope(paramRefl);
+            paramRefl.type = index || !node.constraint
+                ? void 0
+                : context.converter.convertType(paramScope, node.constraint.type);
+            paramRefl.default = param.default
+                ? context.converter.convertType(paramScope, param.default)
+                : void 0;
+            if (param.modifiers?.some((m) => m.kind === ts.SyntaxKind.ConstKeyword)) {
+                paramRefl.flags.setFlag(ReflectionFlag.Const, true);
+            }
+            context.registerReflection(paramRefl, param.symbol);
+            if (ts.isJSDocTemplateTag(param.parent)) {
+                paramRefl.comment = context.getJsDocComment(param.parent);
+            }
+            context.converter.trigger(ConverterEvents.CREATE_TYPE_PARAMETER, context, paramRefl, param);
+            return paramRefl;
+        });
+    });
+}
+function getVariance(modifiers) {
+    const hasIn = modifiers?.some((mod) => mod.kind === ts.SyntaxKind.InKeyword);
+    const hasOut = modifiers?.some((mod) => mod.kind === ts.SyntaxKind.OutKeyword);
+    if (hasIn && hasOut) {
+        return VarianceModifier.inOut;
+    }
+    if (hasIn) {
+        return VarianceModifier.in;
+    }
+    if (hasOut) {
+        return VarianceModifier.out;
+    }
+}
+function convertPredicate(predicate, context) {
+    let name;
+    switch (predicate.kind) {
+        case ts.TypePredicateKind.This:
+        case ts.TypePredicateKind.AssertsThis:
+            name = "this";
+            break;
+        case ts.TypePredicateKind.Identifier:
+        case ts.TypePredicateKind.AssertsIdentifier:
+            name = predicate.parameterName;
+            break;
+    }
+    let asserts;
+    switch (predicate.kind) {
+        case ts.TypePredicateKind.This:
+        case ts.TypePredicateKind.Identifier:
+            asserts = false;
+            break;
+        case ts.TypePredicateKind.AssertsThis:
+        case ts.TypePredicateKind.AssertsIdentifier:
+            asserts = true;
+            break;
+    }
+    return new PredicateType(name, asserts, predicate.type
+        ? context.converter.convertType(context, predicate.type)
+        : void 0);
+}

package/dist/lib/converter/factories/symbol-id.d.ts

@@ -0,0 +1,3 @@
+import { ReflectionSymbolId } from "#models";
+import ts from "typescript";
+export declare function createSymbolIdImpl(symbol: ts.Symbol, declaration?: ts.Declaration): ReflectionSymbolId;

package/dist/lib/converter/factories/symbol-id.js

@@ -0,0 +1,47 @@
+import { ReflectionSymbolId } from "#models";
+import { findPackageForPath, getQualifiedName, normalizePath, resolveDeclarationMaps } from "#node-utils";
+import {} from "#utils";
+import { relative } from "node:path";
+import ts from "typescript";
+let transientCount = 0;
+const transientIds = new WeakMap();
+// Don't use this directly, use Context.createSymbolId instead.
+export function createSymbolIdImpl(symbol, declaration) {
+    declaration ??= symbol.declarations?.[0];
+    const tsSource = declaration?.getSourceFile().fileName ?? "";
+    const sourceFileName = resolveDeclarationMaps(tsSource);
+    let packageName;
+    let packagePath;
+    const packageInfo = findPackageForPath(tsSource);
+    if (packageInfo) {
+        let packageDir;
+        [packageName, packageDir] = packageInfo;
+        packagePath = normalizePath(relative(packageDir, sourceFileName));
+    }
+    else {
+        packageName = ReflectionSymbolId.UNKNOWN_PACKAGE;
+        packagePath = normalizePath(sourceFileName);
+    }
+    let qualifiedName;
+    if (symbol.declarations?.some(ts.isSourceFile)) {
+        qualifiedName = "";
+    }
+    else {
+        qualifiedName = getQualifiedName(symbol, symbol.name);
+    }
+    const pos = declaration?.getStart() ?? Infinity;
+    let transientId = NaN;
+    if (symbol.flags & ts.SymbolFlags.Transient) {
+        transientId = transientIds.get(symbol) ?? ++transientCount;
+        transientIds.set(symbol, transientId);
+    }
+    const id = new ReflectionSymbolId({
+        packageName,
+        packagePath,
+        qualifiedName,
+    });
+    id.pos = pos;
+    id.transientId = transientId;
+    id.fileName = normalizePath(sourceFileName);
+    return id;
+}

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

@@ -0,0 +1,5 @@
+export type { CommentParserConfig } from "./comments/index.js";
+export type { ExternalResolveResult, ExternalSymbolResolver } from "./comments/linkResolver.js";
+export { Context } from "./context.js";
+export { convertDefaultValue, convertExpression } from "./convert-expression.js";
+export { Converter, type ConverterEvents } from "./converter.js";

package/dist/lib/converter/index.js

@@ -0,0 +1,3 @@
+export { Context } from "./context.js";
+export { convertDefaultValue, convertExpression } from "./convert-expression.js";
+export { Converter } from "./converter.js";

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

@@ -0,0 +1,4 @@
+import ts from "typescript";
+import type { Context } from "./context.js";
+export declare function convertJsDocAlias(context: Context, symbol: ts.Symbol, declaration: ts.JSDocTypedefTag | ts.JSDocEnumTag, exportSymbol?: ts.Symbol): undefined;
+export declare function convertJsDocCallback(context: Context, symbol: ts.Symbol, declaration: ts.JSDocCallbackTag, exportSymbol?: ts.Symbol): void;

package/dist/lib/converter/jsdoc.js

@@ -0,0 +1,135 @@
+// Converter functions for JSDoc defined types
+// @typedef
+// @callback
+import { ok } from "assert";
+import ts from "typescript";
+import { DeclarationReflection, IntrinsicType, ReflectionKind, ReflectionType, SignatureReflection, } from "../models/index.js";
+import { ConverterEvents } from "./converter-events.js";
+import { convertConstructSignatures, convertParameterNodes, convertTemplateParameterNodes, createSignature, } from "./factories/signature.js";
+import { i18n } from "#utils";
+import { convertIndexSignatures } from "./factories/index-signature.js";
+// This is almost convertTypeAliasAsInterface, but unfortunately needs to be separate
+// due to type parameters being different in JSDoc comments
+function convertJsDocAliasAsInterface(context, symbol, exportSymbol, declaration) {
+    const reflection = context.createDeclarationReflection(ReflectionKind.Interface, symbol, exportSymbol);
+    context.finalizeDeclarationReflection(reflection);
+    const rc = context.withScope(reflection);
+    const type = context.checker.getTypeAtLocation(declaration);
+    if (type.getFlags() & ts.TypeFlags.Union) {
+        context.logger.warn(i18n.converting_union_as_interface(), declaration);
+    }
+    // Interfaces have properties
+    for (const prop of type.getProperties()) {
+        context.converter.convertSymbol(rc, prop);
+    }
+    // And type parameters
+    convertTemplateParameters(rc, declaration.parent);
+    // And maybe call signatures
+    context.checker
+        .getSignaturesOfType(type, ts.SignatureKind.Call)
+        .forEach((sig) => createSignature(rc, ReflectionKind.CallSignature, sig, symbol));
+    // And maybe constructor signatures
+    convertConstructSignatures(rc, symbol);
+    // And finally, index signatures
+    convertIndexSignatures(rc, type);
+}
+export function convertJsDocAlias(context, symbol, declaration, exportSymbol) {
+    if (declaration.typeExpression &&
+        ts.isJSDocTypeLiteral(declaration.typeExpression)) {
+        convertJsDocInterface(context, declaration, symbol, exportSymbol);
+        return;
+    }
+    const comment = context.getJsDocComment(declaration);
+    if (comment?.hasModifier("@interface")) {
+        return convertJsDocAliasAsInterface(context, symbol, exportSymbol, declaration);
+    }
+    // If the typedef tag is just referring to another type-space symbol, with no type parameters
+    // or appropriate forwarding type parameters, then we treat it as a re-export instead of creating
+    // a type alias with an import type.
+    const aliasedSymbol = getTypedefReExportTarget(context, declaration);
+    if (aliasedSymbol) {
+        context.converter.convertSymbol(context, aliasedSymbol, exportSymbol ?? symbol);
+        return;
+    }
+    const reflection = context.createDeclarationReflection(ReflectionKind.TypeAlias, symbol, exportSymbol);
+    reflection.comment = comment;
+    reflection.type = context.converter.convertType(context.withScope(reflection), declaration.typeExpression?.type);
+    convertTemplateParameters(context.withScope(reflection), declaration.parent);
+    context.finalizeDeclarationReflection(reflection);
+}
+export function convertJsDocCallback(context, symbol, declaration, exportSymbol) {
+    const alias = context.createDeclarationReflection(ReflectionKind.TypeAlias, symbol, exportSymbol);
+    alias.comment = context.getJsDocComment(declaration);
+    context.finalizeDeclarationReflection(alias);
+    const ac = context.withScope(alias);
+    alias.type = convertJsDocSignature(ac, declaration.typeExpression);
+    convertTemplateParameters(ac, declaration.parent);
+}
+function convertJsDocInterface(context, declaration, symbol, exportSymbol) {
+    const reflection = context.createDeclarationReflection(ReflectionKind.Interface, symbol, exportSymbol);
+    reflection.comment = context.getJsDocComment(declaration);
+    context.finalizeDeclarationReflection(reflection);
+    const rc = context.withScope(reflection);
+    const type = context.checker.getDeclaredTypeOfSymbol(symbol);
+    for (const s of type.getProperties()) {
+        context.converter.convertSymbol(rc, s);
+    }
+    convertTemplateParameters(rc, declaration.parent);
+}
+function convertJsDocSignature(context, node) {
+    const symbol = context.getSymbolAtLocation(node) ?? node.symbol;
+    const type = context.getTypeAtLocation(node);
+    if (!symbol || !type) {
+        return new IntrinsicType("Function");
+    }
+    const reflection = new DeclarationReflection("__type", ReflectionKind.TypeLiteral, context.scope);
+    const rc = context.withScope(reflection);
+    context.registerReflection(reflection, symbol);
+    context.converter.trigger(ConverterEvents.CREATE_DECLARATION, context, reflection);
+    const signature = new SignatureReflection("__type", ReflectionKind.CallSignature, reflection);
+    context.project.registerSymbolId(signature, context.createSymbolId(symbol, node));
+    context.registerReflection(signature, void 0);
+    const signatureCtx = rc.withScope(signature);
+    reflection.signatures = [signature];
+    signature.type = context.converter.convertType(signatureCtx, node.type?.typeExpression?.type);
+    signature.parameters = convertParameterNodes(signatureCtx, signature, node.parameters);
+    signature.typeParameters = convertTemplateParameterNodes(context.withScope(reflection), node.typeParameters);
+    return new ReflectionType(reflection);
+}
+function convertTemplateParameters(context, node) {
+    ok(context.scope instanceof DeclarationReflection);
+    context.scope.typeParameters = convertTemplateParameterNodes(context, node.tags?.filter(ts.isJSDocTemplateTag));
+}
+function getTypedefReExportTarget(context, declaration) {
+    const typeExpression = declaration.typeExpression;
+    if (!ts.isJSDocTypedefTag(declaration) ||
+        !typeExpression ||
+        ts.isJSDocTypeLiteral(typeExpression) ||
+        !ts.isImportTypeNode(typeExpression.type) ||
+        !typeExpression.type.qualifier ||
+        !ts.isIdentifier(typeExpression.type.qualifier)) {
+        return;
+    }
+    const targetSymbol = context.expectSymbolAtLocation(typeExpression.type.qualifier);
+    const decl = targetSymbol.declarations?.[0];
+    if (!decl ||
+        !(ts.isTypeAliasDeclaration(decl) ||
+            ts.isInterfaceDeclaration(decl) ||
+            ts.isJSDocTypedefTag(decl) ||
+            ts.isJSDocCallbackTag(decl))) {
+        return;
+    }
+    const targetParams = ts.getEffectiveTypeParameterDeclarations(decl);
+    const localParams = ts.getEffectiveTypeParameterDeclarations(declaration);
+    const localArgs = typeExpression.type.typeArguments || [];
+    // If we have type parameters, ensure they are forwarding parameters with no transformations.
+    // This doesn't check constraints since they aren't checked in JSDoc types.
+    if (targetParams.length !== localParams.length ||
+        localArgs.some((arg, i) => !ts.isTypeReferenceNode(arg) ||
+            !ts.isIdentifier(arg.typeName) ||
+            arg.typeArguments ||
+            localParams[i]?.name.text !== arg.typeName.text)) {
+        return;
+    }
+    return targetSymbol;
+}