@jsdocs-io/extractor/dist/extract-interface.js

The API extractor for npm packages powering jsdocs.io

import { orderBy } from "natural-orderby";
import { docs } from "./docs.js";
import { formatSignature } from "./format-signature.js";
import { headText } from "./head-text.js";
import { id } from "./id.js";
import { isHidden } from "./is-hidden.js";
import { sourceFilePath } from "./source-file-path.js";
import { typeCheckerType } from "./type-checker-type.js";
export async function extractInterface(containerName, exportName, declaration) {
    const interfaceId = id(containerName, "+interface", exportName);
    return {
        kind: "interface",
        id: interfaceId,
        name: exportName,
        docs: docs(declaration),
        file: sourceFilePath(declaration),
        line: declaration.getStartLineNumber(),
        signature: await interfaceSignature(declaration),
        properties: await extractInterfaceProperties(interfaceId, declaration),
        methods: await extractInterfaceMethods(interfaceId, declaration),
        constructSignatures: await extractInterfaceConstructSignatures(interfaceId, declaration),
        callSignatures: await extractInterfaceCallSignatures(interfaceId, declaration),
        indexSignatures: await extractInterfaceIndexSignatures(interfaceId, declaration),
        getAccessors: await extractInterfaceGetAccessors(interfaceId, declaration),
        setAccessors: await extractInterfaceSetAccessors(interfaceId, declaration),
    };
}
async function interfaceSignature(declaration) {
    const signature = headText(declaration);
    return await formatSignature("interface", signature);
}
async function extractInterfaceProperties(interfaceId, interfaceDeclaration) {
    const properties = [];
    for (const declaration of interfaceDeclaration.getProperties()) {
        if (isHidden(declaration))
            continue;
        const name = declaration.getName();
        properties.push({
            kind: "interface-property",
            id: id(interfaceId, "+property", name),
            name,
            docs: docs(declaration),
            file: sourceFilePath(declaration),
            line: declaration.getStartLineNumber(),
            signature: await interfacePropertySignature(declaration),
        });
    }
    return orderBy(properties, "id");
}
async function interfacePropertySignature(declaration) {
    const signature = declaration.getText();
    return await formatSignature("interface-property", signature);
}
async function extractInterfaceMethods(interfaceId, interfaceDeclaration) {
    const methods = [];
    const seenMethods = new Set();
    for (const declaration of interfaceDeclaration.getMethods()) {
        const name = declaration.getName();
        // Skip overloaded methods.
        if (seenMethods.has(name))
            continue;
        if (isHidden(declaration))
            continue;
        seenMethods.add(name);
        methods.push({
            kind: "interface-method",
            id: id(interfaceId, "+method", name),
            name,
            docs: docs(declaration),
            file: sourceFilePath(declaration),
            line: declaration.getStartLineNumber(),
            signature: await interfaceMethodSignature(name, declaration),
        });
    }
    return orderBy(methods, "id");
}
async function interfaceMethodSignature(name, declaration) {
    const type = typeCheckerType(declaration);
    return await formatSignature("interface-method", `${name}: ${type}`);
}
async function extractInterfaceConstructSignatures(interfaceId, interfaceDeclaration) {
    const constructSignatures = [];
    for (const [index, declaration] of interfaceDeclaration.getConstructSignatures().entries()) {
        if (isHidden(declaration))
            continue;
        constructSignatures.push({
            kind: "interface-construct-signature",
            id: id(interfaceId, "construct-signature", index > 0 ? `${index}` : ""),
            name: "construct-signature",
            docs: docs(declaration),
            file: sourceFilePath(declaration),
            line: declaration.getStartLineNumber(),
            signature: await interfaceConstructSignatureSignature(declaration),
        });
    }
    return orderBy(constructSignatures, "id");
}
async function interfaceConstructSignatureSignature(declaration) {
    const signature = declaration.getText();
    return await formatSignature("interface-construct-signature", signature);
}
async function extractInterfaceCallSignatures(interfaceId, interfaceDeclaration) {
    const callSignatures = [];
    for (const [index, declaration] of interfaceDeclaration.getCallSignatures().entries()) {
        if (isHidden(declaration))
            continue;
        callSignatures.push({
            kind: "interface-call-signature",
            id: id(interfaceId, "call-signature", index > 0 ? `${index}` : ""),
            name: "call-signature",
            docs: docs(declaration),
            file: sourceFilePath(declaration),
            line: declaration.getStartLineNumber(),
            signature: await interfaceCallSignatureSignature(declaration),
        });
    }
    return orderBy(callSignatures, "id");
}
async function interfaceCallSignatureSignature(declaration) {
    const signature = declaration.getText();
    return await formatSignature("interface-call-signature", signature);
}
async function extractInterfaceIndexSignatures(interfaceId, interfaceDeclaration) {
    const indexSignatures = [];
    for (const [index, declaration] of interfaceDeclaration.getIndexSignatures().entries()) {
        if (isHidden(declaration))
            continue;
        indexSignatures.push({
            kind: "interface-index-signature",
            id: id(interfaceId, "index-signature", index > 0 ? `${index}` : ""),
            name: "index-signature",
            docs: docs(declaration),
            file: sourceFilePath(declaration),
            line: declaration.getStartLineNumber(),
            signature: await interfaceIndexSignatureSignature(declaration),
        });
    }
    return orderBy(indexSignatures, "id");
}
async function interfaceIndexSignatureSignature(declaration) {
    const signature = declaration.getText();
    return await formatSignature("interface-index-signature", signature);
}
async function extractInterfaceGetAccessors(interfaceId, interfaceDeclaration) {
    const getAccessors = [];
    for (const declaration of interfaceDeclaration.getGetAccessors()) {
        if (isHidden(declaration))
            continue;
        const name = declaration.getName();
        getAccessors.push({
            kind: "interface-get-accessor",
            id: id(interfaceId, "+get-accessor", name),
            name,
            docs: docs(declaration),
            file: sourceFilePath(declaration),
            line: declaration.getStartLineNumber(),
            signature: await interfaceGetAccessorSignature(declaration),
        });
    }
    return orderBy(getAccessors, "id");
}
async function interfaceGetAccessorSignature(declaration) {
    const signature = declaration.getText();
    return await formatSignature("interface-get-accessor", signature);
}
async function extractInterfaceSetAccessors(interfaceId, interfaceDeclaration) {
    const setAccessors = [];
    for (const declaration of interfaceDeclaration.getSetAccessors()) {
        if (isHidden(declaration))
            continue;
        const name = declaration.getName();
        setAccessors.push({
            kind: "interface-set-accessor",
            id: id(interfaceId, "+set-accessor", name),
            name,
            docs: docs(declaration),
            file: sourceFilePath(declaration),
            line: declaration.getStartLineNumber(),
            signature: await interfaceSetAccessorSignature(declaration),
        });
    }
    return orderBy(setAccessors, "id");
}
async function interfaceSetAccessorSignature(declaration) {
    const signature = declaration.getText();
    return await formatSignature("interface-get-accessor", signature);
}