@depup/typedoc 0.28.17-depup.0

package/dist/lib/models/ReflectionSymbolId.d.ts

@@ -0,0 +1,63 @@
+import type { JSONOutput } from "#serialization";
+import { type DeclarationReference, type NormalizedPath } from "#utils";
+/**
+ * See {@link ReflectionSymbolId}
+ */
+export type ReflectionSymbolIdString = string & {
+    readonly __reflectionSymbolId: unique symbol;
+};
+/**
+ * This exists so that TypeDoc can store a unique identifier for a `ts.Symbol` without
+ * keeping a reference to the `ts.Symbol` itself. This identifier should be stable across
+ * runs so long as the symbol is exported from the same file.
+ */
+export declare class ReflectionSymbolId {
+    /**
+     * This will only be used if we somehow cannot find a package.json file for
+     * source code. This is very unlikely, but if it occurs then the {@link packageName}
+     * will be set to this string, and {@link packagePath} will have the absolute path
+     * to the source file.
+     */
+    static readonly UNKNOWN_PACKAGE = "<unknown>";
+    /**
+     * The name of the package which this symbol ID resides within.
+     */
+    readonly packageName: string;
+    /**
+     * Path to the source file containing this symbol.
+     * Note that this is NOT an absolute path, but a package-relative path according
+     * to the directory containing package.json for the package name.
+     */
+    readonly packagePath: NormalizedPath;
+    /**
+     * Qualified name of this symbol within the source file.
+     */
+    readonly qualifiedName: string;
+    /**
+     * Note: This is **not** serialized. It exists for sorting by declaration order, but
+     * should not be needed when deserializing from JSON.
+     * Will be set to `Infinity` if the ID was deserialized from JSON.
+     */
+    pos: number;
+    /**
+     * Note: This is **not** serialized. It exists to support detection of the differences between
+     * symbols which share declarations, but are instantiated with different type parameters.
+     * This will be `NaN` if the symbol reference is not transient.
+     * Note: This can only be non-NaN if {@link pos} is finite.
+     */
+    transientId: number;
+    /**
+     * Note: This is **not** serialized, only {@link packageName} and {@link packagePath} path
+     * information is preserved when serializing. This is set so that it is available to plugins
+     * when initially converting a project.
+     *
+     * @privateRemarks
+     * This is used by typedoc-plugin-dt-links to determine the path to read to get the source
+     * code of a definitely typed package.
+     */
+    fileName?: NormalizedPath;
+    constructor(json: JSONOutput.ReflectionSymbolId);
+    getStableKey(): ReflectionSymbolIdString;
+    toDeclarationReference(): DeclarationReference;
+    toObject(): JSONOutput.ReflectionSymbolId;
+}

package/dist/lib/models/ReflectionSymbolId.js

@@ -0,0 +1,85 @@
+import {} from "#utils";
+import { splitUnquotedString } from "./utils.js";
+/**
+ * This exists so that TypeDoc can store a unique identifier for a `ts.Symbol` without
+ * keeping a reference to the `ts.Symbol` itself. This identifier should be stable across
+ * runs so long as the symbol is exported from the same file.
+ */
+export class ReflectionSymbolId {
+    /**
+     * This will only be used if we somehow cannot find a package.json file for
+     * source code. This is very unlikely, but if it occurs then the {@link packageName}
+     * will be set to this string, and {@link packagePath} will have the absolute path
+     * to the source file.
+     */
+    static UNKNOWN_PACKAGE = "<unknown>";
+    /**
+     * The name of the package which this symbol ID resides within.
+     */
+    packageName;
+    /**
+     * Path to the source file containing this symbol.
+     * Note that this is NOT an absolute path, but a package-relative path according
+     * to the directory containing package.json for the package name.
+     */
+    packagePath;
+    /**
+     * Qualified name of this symbol within the source file.
+     */
+    qualifiedName;
+    /**
+     * Note: This is **not** serialized. It exists for sorting by declaration order, but
+     * should not be needed when deserializing from JSON.
+     * Will be set to `Infinity` if the ID was deserialized from JSON.
+     */
+    pos = Infinity;
+    /**
+     * Note: This is **not** serialized. It exists to support detection of the differences between
+     * symbols which share declarations, but are instantiated with different type parameters.
+     * This will be `NaN` if the symbol reference is not transient.
+     * Note: This can only be non-NaN if {@link pos} is finite.
+     */
+    transientId = NaN;
+    /**
+     * Note: This is **not** serialized, only {@link packageName} and {@link packagePath} path
+     * information is preserved when serializing. This is set so that it is available to plugins
+     * when initially converting a project.
+     *
+     * @privateRemarks
+     * This is used by typedoc-plugin-dt-links to determine the path to read to get the source
+     * code of a definitely typed package.
+     */
+    fileName;
+    constructor(json) {
+        this.packageName = json.packageName;
+        this.packagePath = json.packagePath;
+        this.qualifiedName = json.qualifiedName;
+    }
+    getStableKey() {
+        if (Number.isFinite(this.pos)) {
+            return `${this.packageName}\0${this.packagePath}\0${this.qualifiedName}\0${this.pos}\0${this.transientId}`;
+        }
+        else {
+            return `${this.packageName}\0${this.packagePath}\0${this.qualifiedName}`;
+        }
+    }
+    toDeclarationReference() {
+        return {
+            resolutionStart: "global",
+            moduleSource: this.packageName,
+            symbolReference: {
+                path: splitUnquotedString(this.qualifiedName, ".").map((path) => ({
+                    navigation: ".",
+                    path,
+                })),
+            },
+        };
+    }
+    toObject() {
+        return {
+            packageName: this.packageName,
+            packagePath: this.packagePath,
+            qualifiedName: this.qualifiedName,
+        };
+    }
+}

package/dist/lib/models/SignatureReflection.d.ts

@@ -0,0 +1,50 @@
+import { type ReferenceType, type SomeType } from "./types.js";
+import { Reflection, type TraverseCallback } from "./Reflection.js";
+import type { ParameterReflection } from "./ParameterReflection.js";
+import type { TypeParameterReflection } from "./TypeParameterReflection.js";
+import type { DeclarationReflection } from "./DeclarationReflection.js";
+import type { ReflectionKind } from "./kind.js";
+import type { Deserializer, JSONOutput, Serializer } from "#serialization";
+import { SourceReference } from "./SourceReference.js";
+/**
+ * @category Reflections
+ */
+export declare class SignatureReflection extends Reflection {
+    readonly variant = "signature";
+    constructor(name: string, kind: SignatureReflection["kind"], parent: DeclarationReflection);
+    kind: ReflectionKind.SetSignature | ReflectionKind.GetSignature | ReflectionKind.IndexSignature | ReflectionKind.CallSignature | ReflectionKind.ConstructorSignature;
+    parent: DeclarationReflection;
+    /**
+     * A list of all source files that contributed to this reflection.
+     */
+    sources?: SourceReference[];
+    parameters?: ParameterReflection[];
+    typeParameters?: TypeParameterReflection[];
+    type?: SomeType;
+    /**
+     * A type that points to the reflection that has been overwritten by this reflection.
+     *
+     * Applies to interface and class members.
+     */
+    overwrites?: ReferenceType;
+    /**
+     * A type that points to the reflection this reflection has been inherited from.
+     *
+     * Applies to interface and class members.
+     */
+    inheritedFrom?: ReferenceType;
+    /**
+     * A type that points to the reflection this reflection is the implementation of.
+     *
+     * Applies to class members.
+     */
+    implementationOf?: ReferenceType;
+    traverse(callback: TraverseCallback): void;
+    isSignature(): this is SignatureReflection;
+    /**
+     * Return a string representation of this reflection.
+     */
+    toString(): string;
+    toObject(serializer: Serializer): JSONOutput.SignatureReflection;
+    fromObject(de: Deserializer, obj: JSONOutput.SignatureReflection): void;
+}

package/dist/lib/models/SignatureReflection.js

@@ -0,0 +1,96 @@
+import { ReflectionType } from "./types.js";
+import { Reflection, TraverseProperty } from "./Reflection.js";
+import { SourceReference } from "./SourceReference.js";
+/**
+ * @category Reflections
+ */
+export class SignatureReflection extends Reflection {
+    variant = "signature";
+    // ESLint is wrong, we're restricting types to be more narrow.
+    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+    constructor(name, kind, parent) {
+        super(name, kind, parent);
+    }
+    /**
+     * A list of all source files that contributed to this reflection.
+     */
+    sources;
+    parameters;
+    typeParameters;
+    type;
+    /**
+     * A type that points to the reflection that has been overwritten by this reflection.
+     *
+     * Applies to interface and class members.
+     */
+    overwrites;
+    /**
+     * A type that points to the reflection this reflection has been inherited from.
+     *
+     * Applies to interface and class members.
+     */
+    inheritedFrom;
+    /**
+     * A type that points to the reflection this reflection is the implementation of.
+     *
+     * Applies to class members.
+     */
+    implementationOf;
+    traverse(callback) {
+        if (this.type instanceof ReflectionType) {
+            if (callback(this.type.declaration, TraverseProperty.TypeLiteral) === false) {
+                return;
+            }
+        }
+        for (const parameter of this.typeParameters?.slice() || []) {
+            if (callback(parameter, TraverseProperty.TypeParameter) === false) {
+                return;
+            }
+        }
+        for (const parameter of this.parameters?.slice() || []) {
+            if (callback(parameter, TraverseProperty.Parameters) === false) {
+                return;
+            }
+        }
+    }
+    isSignature() {
+        return true;
+    }
+    /**
+     * Return a string representation of this reflection.
+     */
+    toString() {
+        let result = super.toString();
+        if (this.typeParameters) {
+            const parameters = this.typeParameters.map((parameter) => parameter.name);
+            result += "<" + parameters.join(", ") + ">";
+        }
+        if (this.type) {
+            result += ": " + this.type.toString();
+        }
+        return result;
+    }
+    toObject(serializer) {
+        return {
+            ...super.toObject(serializer),
+            variant: this.variant,
+            sources: serializer.toObjectsOptional(this.sources),
+            typeParameters: serializer.toObjectsOptional(this.typeParameters),
+            parameters: serializer.toObjectsOptional(this.parameters),
+            type: serializer.toObject(this.type),
+            overwrites: serializer.toObject(this.overwrites),
+            inheritedFrom: serializer.toObject(this.inheritedFrom),
+            implementationOf: serializer.toObject(this.implementationOf),
+        };
+    }
+    fromObject(de, obj) {
+        super.fromObject(de, obj);
+        this.sources = de.reviveMany(obj.sources, (t) => new SourceReference(t.fileName, t.line, t.character));
+        this.typeParameters = de.reviveMany(obj.typeParameters, (t) => de.constructReflection(t));
+        this.parameters = de.reviveMany(obj.parameters, (t) => de.constructReflection(t));
+        this.type = de.reviveType(obj.type);
+        this.overwrites = de.reviveType(obj.overwrites);
+        this.inheritedFrom = de.reviveType(obj.inheritedFrom);
+        this.implementationOf = de.reviveType(obj.implementationOf);
+    }
+}

package/dist/lib/models/SourceReference.d.ts

@@ -0,0 +1,33 @@
+import type { Deserializer, JSONOutput } from "#serialization";
+/**
+ * Represents references of reflections to their defining source files.
+ *
+ * @see {@link DeclarationReflection.sources}
+ */
+export declare class SourceReference {
+    /**
+     * The filename of the source file.
+     */
+    fileName: string;
+    /**
+     * The absolute filename of the source file.
+     * @internal
+     */
+    fullFileName: string;
+    /**
+     * The one based number of the line that emitted the declaration.
+     */
+    line: number;
+    /**
+     * The index of the character that emitted the declaration.
+     */
+    character: number;
+    /**
+     * URL for displaying the source file.
+     */
+    url?: string;
+    constructor(fileName: string, line: number, character: number);
+    equals(other: SourceReference): boolean;
+    toObject(): JSONOutput.SourceReference;
+    fromObject(_de: Deserializer, obj: JSONOutput.SourceReference): void;
+}

package/dist/lib/models/SourceReference.js

@@ -0,0 +1,50 @@
+/**
+ * Represents references of reflections to their defining source files.
+ *
+ * @see {@link DeclarationReflection.sources}
+ */
+export class SourceReference {
+    /**
+     * The filename of the source file.
+     */
+    fileName;
+    /**
+     * The absolute filename of the source file.
+     * @internal
+     */
+    fullFileName;
+    /**
+     * The one based number of the line that emitted the declaration.
+     */
+    line;
+    /**
+     * The index of the character that emitted the declaration.
+     */
+    character;
+    /**
+     * URL for displaying the source file.
+     */
+    url;
+    constructor(fileName, line, character) {
+        this.fileName = fileName;
+        this.fullFileName = fileName;
+        this.line = line;
+        this.character = character;
+    }
+    equals(other) {
+        return (this.fullFileName == other.fullFileName &&
+            this.line === other.line &&
+            this.character === other.character);
+    }
+    toObject() {
+        return {
+            fileName: this.fileName,
+            line: this.line,
+            character: this.character,
+            url: this.url,
+        };
+    }
+    fromObject(_de, obj) {
+        this.url = obj.url;
+    }
+}

package/dist/lib/models/TypeParameterReflection.d.ts

@@ -0,0 +1,30 @@
+import type { SomeType } from "./types.js";
+import { Reflection, type TraverseCallback } from "./Reflection.js";
+import type { DeclarationReflection } from "./DeclarationReflection.js";
+import type { Deserializer, JSONOutput, Serializer } from "#serialization";
+import type { SignatureReflection } from "./SignatureReflection.js";
+/**
+ * Modifier flags for type parameters, added in TS 4.7
+ * @enum
+ */
+export declare const VarianceModifier: {
+    readonly in: "in";
+    readonly out: "out";
+    readonly inOut: "in out";
+};
+export type VarianceModifier = (typeof VarianceModifier)[keyof typeof VarianceModifier];
+/**
+ * @category Reflections
+ */
+export declare class TypeParameterReflection extends Reflection {
+    readonly variant = "typeParam";
+    parent?: DeclarationReflection | SignatureReflection;
+    type?: SomeType;
+    default?: SomeType;
+    varianceModifier?: VarianceModifier;
+    constructor(name: string, parent: Reflection, varianceModifier: VarianceModifier | undefined);
+    isTypeParameter(): this is TypeParameterReflection;
+    toObject(serializer: Serializer): JSONOutput.TypeParameterReflection;
+    fromObject(de: Deserializer, obj: JSONOutput.TypeParameterReflection): void;
+    traverse(_callback: TraverseCallback): void;
+}

package/dist/lib/models/TypeParameterReflection.js

@@ -0,0 +1,45 @@
+import { Reflection } from "./Reflection.js";
+import { ReflectionKind } from "./kind.js";
+/**
+ * Modifier flags for type parameters, added in TS 4.7
+ * @enum
+ */
+export const VarianceModifier = {
+    in: "in",
+    out: "out",
+    inOut: "in out",
+};
+/**
+ * @category Reflections
+ */
+export class TypeParameterReflection extends Reflection {
+    variant = "typeParam";
+    type;
+    default;
+    varianceModifier;
+    constructor(name, parent, varianceModifier) {
+        super(name, ReflectionKind.TypeParameter, parent);
+        this.varianceModifier = varianceModifier;
+    }
+    isTypeParameter() {
+        return true;
+    }
+    toObject(serializer) {
+        return {
+            ...super.toObject(serializer),
+            variant: this.variant,
+            type: serializer.toObject(this.type),
+            default: serializer.toObject(this.default),
+            varianceModifier: this.varianceModifier,
+        };
+    }
+    fromObject(de, obj) {
+        super.fromObject(de, obj);
+        this.type = de.reviveType(obj.type);
+        this.default = de.reviveType(obj.default);
+        this.varianceModifier = obj.varianceModifier;
+    }
+    traverse(_callback) {
+        // do nothing, no child reflections.
+    }
+}

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

@@ -0,0 +1,19 @@
+export * from "./Comment.js";
+export * from "./ContainerReflection.js";
+export * from "./DeclarationReflection.js";
+export * from "./DocumentReflection.js";
+export * from "./FileRegistry.js";
+export * from "./kind.js";
+export * from "./ParameterReflection.js";
+export { ProjectReflection } from "./ProjectReflection.js";
+export * from "./ReferenceReflection.js";
+export * from "./Reflection.js";
+export * from "./ReflectionCategory.js";
+export * from "./ReflectionGroup.js";
+export * from "./ReflectionSymbolId.js";
+export * from "./SignatureReflection.js";
+export * from "./SourceReference.js";
+export * from "./TypeParameterReflection.js";
+export * from "./types.js";
+export * from "./utils.js";
+export * from "./variant.js";

package/dist/lib/models/index.js

@@ -0,0 +1,19 @@
+export * from "./Comment.js";
+export * from "./ContainerReflection.js";
+export * from "./DeclarationReflection.js";
+export * from "./DocumentReflection.js";
+export * from "./FileRegistry.js";
+export * from "./kind.js";
+export * from "./ParameterReflection.js";
+export { ProjectReflection } from "./ProjectReflection.js";
+export * from "./ReferenceReflection.js";
+export * from "./Reflection.js";
+export * from "./ReflectionCategory.js";
+export * from "./ReflectionGroup.js";
+export * from "./ReflectionSymbolId.js";
+export * from "./SignatureReflection.js";
+export * from "./SourceReference.js";
+export * from "./TypeParameterReflection.js";
+export * from "./types.js";
+export * from "./utils.js";
+export * from "./variant.js";

package/dist/lib/models/kind.d.ts

@@ -0,0 +1,84 @@
+import { type EnumKeys } from "#utils";
+/**
+ * Defines the available reflection kinds.
+ * @category Reflections
+ */
+export declare enum ReflectionKind {
+    Project = 1,
+    Module = 2,
+    Namespace = 4,
+    Enum = 8,
+    EnumMember = 16,
+    Variable = 32,
+    Function = 64,
+    Class = 128,
+    Interface = 256,
+    Constructor = 512,
+    Property = 1024,
+    Method = 2048,
+    CallSignature = 4096,
+    IndexSignature = 8192,
+    ConstructorSignature = 16384,
+    Parameter = 32768,
+    TypeLiteral = 65536,
+    TypeParameter = 131072,
+    Accessor = 262144,
+    GetSignature = 524288,
+    SetSignature = 1048576,
+    TypeAlias = 2097152,
+    Reference = 4194304,
+    /**
+     * Generic non-ts content to be included in the generated docs as its own page.
+     */
+    Document = 8388608
+}
+/** @category Reflections */
+export declare namespace ReflectionKind {
+    type KindString = EnumKeys<typeof ReflectionKind>;
+    /** @internal */
+    const All: number;
+    /** @internal */
+    const ClassOrInterface: number;
+    /** @internal */
+    const VariableOrProperty: number;
+    /** @internal */
+    const FunctionOrMethod: number;
+    /** @internal */
+    const ClassMember: number;
+    /** @internal */
+    const SomeSignature: number;
+    /** @internal */
+    const SomeModule: number;
+    /** @internal */
+    const SomeType: number;
+    /** @internal */
+    const SomeValue: number;
+    /** @internal */
+    const SomeMember: number;
+    /** @internal */
+    const SomeExport: number;
+    /** @internal */
+    const MayContainDocuments: number;
+    /** @internal */
+    const ExportContainer: number;
+    /** @internal */
+    const Inheritable: number;
+    /** @internal */
+    const ContainsCallSignatures: number;
+    /** @internal */
+    const TypeReferenceTarget: number;
+    /** @internal */
+    const ValueReferenceTarget: number;
+    /**
+     * Note: This does not include Class/Interface, even though they technically could contain index signatures
+     * @internal
+     */
+    const SignatureContainer: number;
+    /** @internal */
+    const VariableContainer: number;
+    /** @internal */
+    const MethodContainer: number;
+    function singularString(kind: ReflectionKind): import("#utils").TranslatedString;
+    function pluralString(kind: ReflectionKind): string;
+    function classString(kind: ReflectionKind): string;
+}