typedoc 0.28.18 → 0.28.20

package/dist/lib/output/themes/default/partials/navigation.js

@@ -1,144 +0,0 @@
-import { ReflectionFlag, ReflectionFlags } from "../../../../models/index.js";
-import { i18n, JSX, translateTagName } from "#utils";
-import { classNames, getDisplayName, wbr } from "../../lib.js";
-export function sidebar(context, props) {
-    return (JSX.createElement(JSX.Fragment, null,
-        context.sidebarLinks(),
-        context.navigation(props)));
-}
-function buildFilterItem(context, name, displayName, defaultValue) {
-    return (JSX.createElement("li", { class: "tsd-filter-item" },
-        JSX.createElement("label", { class: "tsd-filter-input" },
-            JSX.createElement("input", { type: "checkbox", id: `tsd-filter-${name}`, name: name, checked: defaultValue }),
-            context.icons.checkbox(),
-            JSX.createElement("span", null, displayName))));
-}
-export function sidebarLinks(context) {
-    const links = Object.entries(context.options.getValue("sidebarLinks"));
-    const navLinks = Object.entries(context.options.getValue("navigationLinks"));
-    if (!links.length && !navLinks.length)
-        return null;
-    return (JSX.createElement("nav", { id: "tsd-sidebar-links", class: "tsd-navigation" },
-        links.map(([label, url]) => JSX.createElement("a", { href: url }, label)),
-        navLinks.map(([label, url]) => (JSX.createElement("a", { href: url, class: "tsd-nav-link" }, label)))));
-}
-const flagOptionNameToReflectionFlag = {
-    protected: ReflectionFlag.Protected,
-    private: ReflectionFlag.Private,
-    external: ReflectionFlag.External,
-    inherited: ReflectionFlag.Inherited,
-};
-export function settings(context) {
-    const defaultFilters = context.options.getValue("visibilityFilters");
-    const visibilityOptions = [];
-    for (const key of Object.keys(defaultFilters)) {
-        if (key.startsWith("@")) {
-            const filterName = key
-                .substring(1)
-                .replace(/([a-z])([A-Z])/g, "$1-$2")
-                .toLowerCase();
-            visibilityOptions.push(buildFilterItem(context, filterName, translateTagName(key), defaultFilters[key]));
-        }
-        else if ((key === "protected" && !context.options.getValue("excludeProtected")) ||
-            (key === "private" && !context.options.getValue("excludePrivate")) ||
-            (key === "external" && !context.options.getValue("excludeExternals")) ||
-            key === "inherited") {
-            visibilityOptions.push(buildFilterItem(context, key, ReflectionFlags.flagString(flagOptionNameToReflectionFlag[key]), defaultFilters[key]));
-        }
-    }
-    // Settings panel above navigation
-    return (JSX.createElement("div", { class: "tsd-navigation settings" },
-        JSX.createElement("details", { class: "tsd-accordion", open: false },
-            JSX.createElement("summary", { class: "tsd-accordion-summary" },
-                context.icons.chevronDown(),
-                JSX.createElement("h3", null, i18n.theme_settings())),
-            JSX.createElement("div", { class: "tsd-accordion-details" },
-                !!visibilityOptions.length && (JSX.createElement("div", { class: "tsd-filter-visibility" },
-                    JSX.createElement("span", { class: "settings-label" }, i18n.theme_member_visibility()),
-                    JSX.createElement("ul", { id: "tsd-filter-options" }, ...visibilityOptions))),
-                JSX.createElement("div", { class: "tsd-theme-toggle" },
-                    JSX.createElement("label", { class: "settings-label", for: "tsd-theme" }, i18n.theme_theme()),
-                    JSX.createElement("select", { id: "tsd-theme" },
-                        JSX.createElement("option", { value: "os" }, i18n.theme_os()),
-                        JSX.createElement("option", { value: "light" }, i18n.theme_light()),
-                        JSX.createElement("option", { value: "dark" }, i18n.theme_dark())))))));
-}
-export const navigation = function navigation(context, props) {
-    return (JSX.createElement("nav", { class: "tsd-navigation" },
-        JSX.createElement("a", { href: context.urlTo(props.project), class: classNames({
-                current: props.url === context.router.getFullUrl(props.model) && props.model.isProject(),
-            }) }, getDisplayName(props.project)),
-        JSX.createElement("ul", { class: "tsd-small-nested-navigation", id: "tsd-nav-container" },
-            JSX.createElement("li", null, i18n.theme_loading()))));
-};
-export function pageSidebar(context, props) {
-    return (JSX.createElement(JSX.Fragment, null,
-        context.settings(),
-        context.pageNavigation(props)));
-}
-function buildSectionNavigation(context, headings) {
-    const levels = [[]];
-    function finalizeLevel(finishedHandlingHeadings) {
-        const level = levels.pop();
-        if (levels[levels.length - 1].length === 0 && finishedHandlingHeadings) {
-            levels[levels.length - 1] = level;
-            return;
-        }
-        const built = (JSX.createElement("ul", null, level.map((l) => JSX.createElement("li", null, l))));
-        levels[levels.length - 1].push(built);
-    }
-    function getInferredHeadingLevel(heading) {
-        if (heading.level) {
-            // Regular heading
-            return heading.level + 2;
-        }
-        if (heading.kind) {
-            // Reflection
-            return 2;
-        }
-        // Group/category
-        return 1;
-    }
-    for (const heading of headings) {
-        const inferredLevel = getInferredHeadingLevel(heading);
-        while (inferredLevel < levels.length) {
-            finalizeLevel(false);
-        }
-        while (inferredLevel > levels.length) {
-            // Lower level than before
-            levels.push([]);
-        }
-        levels[levels.length - 1].push(JSX.createElement("a", { href: heading.link, class: classNames({}, heading.classes) },
-            heading.icon && context.icons[heading.icon](),
-            JSX.createElement("span", null, wbr(heading.text))));
-    }
-    while (levels.length > 1) {
-        finalizeLevel(true);
-    }
-    levels.unshift([]);
-    finalizeLevel(true);
-    return levels[0];
-}
-export function pageNavigation(context, props) {
-    if (!props.pageSections.some((sect) => sect.headings.length)) {
-        return JSX.createElement(JSX.Fragment, null);
-    }
-    const sections = [];
-    for (const section of props.pageSections) {
-        if (section.title) {
-            sections.push(JSX.createElement("details", { open: true, class: "tsd-accordion tsd-page-navigation-section" },
-                JSX.createElement("summary", { class: "tsd-accordion-summary", "data-key": `section-${section.title}` },
-                    context.icons.chevronDown(),
-                    section.title),
-                JSX.createElement("div", null, buildSectionNavigation(context, section.headings))));
-        }
-        else {
-            sections.push(buildSectionNavigation(context, section.headings));
-        }
-    }
-    return (JSX.createElement("details", { open: true, class: "tsd-accordion tsd-page-navigation" },
-        JSX.createElement("summary", { class: "tsd-accordion-summary" },
-            context.icons.chevronDown(),
-            JSX.createElement("h3", null, i18n.theme_on_this_page())),
-        JSX.createElement("div", { class: "tsd-accordion-details" }, sections)));
-}

package/dist/lib/output/themes/default/partials/reflectionPreview.js

@@ -1,26 +0,0 @@
-import { DeclarationReflection, ReflectionKind } from "../../../../models/index.js";
-import { JSX } from "#utils";
-import { FormattedCodeBuilder, FormattedCodeGenerator, Wrap } from "../../../formatter.js";
-export function reflectionPreview(context, props) {
-    if (!(props instanceof DeclarationReflection))
-        return;
-    // Each property of the interface will have a member rendered later on the page describing it, so generate
-    // a type-like object with links to each member. Don't do this if we don't have any children as it will
-    // generate a broken looking interface. (See TraverseCallback)
-    if (props.kindOf(ReflectionKind.Interface) && props.children) {
-        const builder = new FormattedCodeBuilder(context.router, context.model);
-        const tree = builder.interface(props);
-        const generator = new FormattedCodeGenerator(context.options.getValue("typePrintWidth"));
-        generator.forceWrap(builder.forceWrap); // Ensure elements are added to new lines.
-        generator.node(tree, Wrap.Enable);
-        return JSX.createElement("div", { class: "tsd-signature" }, generator.toElement());
-    }
-    if (props.kindOf(ReflectionKind.TypeAlias) && props.children) {
-        const builder = new FormattedCodeBuilder(context.router, context.model);
-        const tree = builder.typeAlias(props);
-        const generator = new FormattedCodeGenerator(context.options.getValue("typePrintWidth"));
-        generator.forceWrap(builder.forceWrap); // Ensure elements are added to new lines.
-        generator.node(tree, Wrap.Enable);
-        return JSX.createElement("div", { class: "tsd-signature" }, generator.toElement());
-    }
-}

package/dist/lib/output/themes/default/partials/toolbar.js

@@ -1,13 +0,0 @@
-import { i18n, JSX } from "#utils";
-import { getDisplayName } from "../../lib.js";
-export const toolbar = (context, props) => (JSX.createElement("header", { class: "tsd-page-toolbar" },
-    JSX.createElement("div", { class: "tsd-toolbar-contents container" },
-        JSX.createElement("a", { href: context.options.getValue("titleLink") || context.relativeURL("index.html"), class: "title" }, getDisplayName(props.project)),
-        JSX.createElement("div", { id: "tsd-toolbar-links" }, Object.entries(context.options.getValue("navigationLinks")).map(([label, url]) => (JSX.createElement("a", { href: url }, label)))),
-        JSX.createElement("button", { id: "tsd-search-trigger", class: "tsd-widget", "aria-label": i18n.theme_search() }, context.icons.search()),
-        JSX.createElement("dialog", { id: "tsd-search", "aria-label": i18n.theme_search() },
-            JSX.createElement("input", { role: "combobox", id: "tsd-search-input", "aria-controls": "tsd-search-results", "aria-autocomplete": "list", "aria-expanded": "true", spellcheck: false, autocapitalize: "off", autocomplete: "off", placeholder: i18n.theme_search_placeholder(), maxLength: 100 }),
-            JSX.createElement("ul", { role: "listbox", id: "tsd-search-results" }),
-            JSX.createElement("div", { id: "tsd-search-status", "aria-live": "polite", "aria-atomic": "true" },
-                JSX.createElement("div", null, i18n.theme_preparing_search_index()))),
-        JSX.createElement("a", { href: "#", class: "tsd-widget menu", id: "tsd-toolbar-menu-trigger", "data-toggle": "menu", "aria-label": i18n.theme_menu() }, context.icons.menu()))));

package/dist/lib/output/themes/default/partials/type.js

@@ -1,9 +0,0 @@
-import { FormattedCodeBuilder, FormattedCodeGenerator, Wrap } from "../../../formatter.js";
-import { TypeContext } from "../../../../models/types.js";
-export function type(context, type, options = { topLevelLinks: false }) {
-    const builder = new FormattedCodeBuilder(context.router, context.model);
-    const tree = builder.type(type, TypeContext.none, options);
-    const generator = new FormattedCodeGenerator(context.options.getValue("typePrintWidth"));
-    generator.node(tree, Wrap.Detect);
-    return generator.toElement();
-}

package/dist/lib/output/themes/default/partials/typeAndParent.js

@@ -1,28 +0,0 @@
-import { ArrayType, ReferenceType, SignatureReflection } from "#models";
-import { JSX } from "#utils";
-export const typeAndParent = (context, props) => {
-    if (props instanceof ArrayType) {
-        return (JSX.createElement(JSX.Fragment, null,
-            context.typeAndParent(props.elementType),
-            "[]"));
-    }
-    if (props instanceof ReferenceType) {
-        if (props.reflection) {
-            const refl = props.reflection instanceof SignatureReflection ? props.reflection.parent : props.reflection;
-            const parent = refl.parent;
-            return (JSX.createElement(JSX.Fragment, null,
-                JSX.createElement("a", { href: context.urlTo(parent) }, parent.name),
-                ".",
-                JSX.createElement("a", { href: context.urlTo(refl) }, refl.name)));
-        }
-        else if (props.externalUrl) {
-            if (props.externalUrl === "#") {
-                return JSX.createElement(JSX.Fragment, null, props.toString());
-            }
-            else {
-                return JSX.createElement("a", { href: props.externalUrl, class: "external", target: "_blank" }, props.name);
-            }
-        }
-    }
-    return JSX.createElement(JSX.Fragment, null, props.toString());
-};

package/dist/lib/output/themes/default/partials/typeDetails.js

@@ -1,284 +0,0 @@
-import { Comment, Reflection, ReflectionKind, } from "../../../../models/index.js";
-import { assert, i18n, JSX } from "#utils";
-import { classNames, getKindClass } from "../../lib.js";
-import { anchorTargetIfPresent } from "./anchor-icon.js";
-function renderingTypeDetailsIsUseful(container, type, notRenderedTags) {
-    const isUsefulVisitor = {
-        array(type) {
-            return renderingTypeDetailsIsUseful(container, type.elementType, notRenderedTags);
-        },
-        intersection(type) {
-            return type.types.some(t => renderingTypeDetailsIsUseful(container, t, notRenderedTags));
-        },
-        union(type) {
-            return !!type.elementSummaries ||
-                type.types.some(t => renderingTypeDetailsIsUseful(container, t, notRenderedTags));
-        },
-        reflection(type) {
-            return renderingChildIsUseful(type.declaration, notRenderedTags);
-        },
-        reference(type) {
-            return shouldExpandReference(container, type);
-        },
-    };
-    return type.visit(isUsefulVisitor) ?? false;
-}
-export function typeDeclaration(context, reflectionOwningType, type) {
-    assert(reflectionOwningType instanceof Reflection, "typeDeclaration(reflectionOwningType, type) called incorrectly");
-    if (renderingTypeDetailsIsUseful(reflectionOwningType, type, context.options.getValue("notRenderedTags"))) {
-        return (JSX.createElement("div", { class: "tsd-type-declaration" },
-            JSX.createElement("h4", null, i18n.theme_type_declaration()),
-            context.typeDetails(reflectionOwningType, type, true)));
-    }
-    return null;
-}
-const expandTypeCache = new WeakMap();
-function getExpandTypeInfo(refl) {
-    const cache = expandTypeCache.get(refl);
-    if (cache)
-        return cache;
-    const expandType = new Set();
-    const preventExpand = new Set();
-    if (!refl.isProject()) {
-        const info = getExpandTypeInfo(refl.parent);
-        for (const item of info.expandType) {
-            expandType.add(item);
-        }
-        for (const item of info.preventExpand) {
-            preventExpand.add(item);
-        }
-    }
-    for (const tag of refl.comment?.blockTags || []) {
-        if (tag.tag === "@expandType") {
-            const name = Comment.combineDisplayParts(tag.content);
-            expandType.add(name);
-            preventExpand.delete(name);
-        }
-        else if (tag.tag === "@preventExpand") {
-            const name = Comment.combineDisplayParts(tag.content);
-            preventExpand.add(name);
-            expandType.delete(name);
-        }
-    }
-    expandTypeCache.set(refl, { expandType, preventExpand });
-    return { expandType, preventExpand };
-}
-const expanded = new Set();
-function shouldExpandReference(container, reference) {
-    const target = reference.reflection;
-    if (!target) {
-        // If it doesn't exist, expand only if there are specific properties
-        // which the user annotated. Assume they know what they're doing.
-        return reference.highlightedProperties !== undefined;
-    }
-    // Prevent expansion of non-types
-    if (!target.kindOf(ReflectionKind.TypeAlias | ReflectionKind.Interface))
-        return false;
-    // Prevent recursive expand
-    if (expanded.has(target))
-        return false;
-    const info = getExpandTypeInfo(container);
-    // Expand if the user explicitly requested it with @param or @expand
-    if (reference.highlightedProperties || target.comment?.hasModifier("@expand") || info.expandType.has(target.name)) {
-        return !info.preventExpand.has(target.name);
-    }
-    return false;
-}
-export function typeDetails(context, reflectionOwningType, type, renderAnchors) {
-    return typeDetailsImpl(context, reflectionOwningType, type, renderAnchors);
-}
-export function typeDetailsImpl(context, reflectionOwningType, type, renderAnchors, highlighted) {
-    const result = type.visit({
-        array(type) {
-            return context.typeDetails(reflectionOwningType, type.elementType, renderAnchors);
-        },
-        intersection(type) {
-            return type.types.map((t) => context.typeDetails(reflectionOwningType, t, renderAnchors));
-        },
-        union(type) {
-            const result = [];
-            for (let i = 0; i < type.types.length; ++i) {
-                result.push(JSX.createElement("li", null,
-                    context.type(type.types[i]),
-                    context.displayParts(type.elementSummaries?.[i]),
-                    context.typeDetailsIfUseful(reflectionOwningType, type.types[i])));
-            }
-            return JSX.createElement("ul", null, result);
-        },
-        reflection(type) {
-            const declaration = type.declaration;
-            if (highlighted) {
-                return highlightedDeclarationDetails(context, declaration, renderAnchors, highlighted);
-            }
-            return declarationDetails(context, declaration, renderAnchors);
-        },
-        reference(reference) {
-            if (shouldExpandReference(reflectionOwningType, reference)) {
-                const target = reference.reflection;
-                if (!target?.isDeclaration()) {
-                    return highlightedPropertyDetails(context, reference.highlightedProperties);
-                }
-                // Ensure we don't go into an infinite loop here
-                expanded.add(target);
-                const details = target.type
-                    ? context.typeDetails(reflectionOwningType, target.type, renderAnchors)
-                    : declarationDetails(context, target, renderAnchors);
-                expanded.delete(target);
-                return details;
-            }
-        },
-        // tuple??
-    });
-    if (!result && highlighted) {
-        return highlightedPropertyDetails(context, highlighted);
-    }
-    return result;
-}
-export function typeDetailsIfUseful(context, reflectionOwningType, type) {
-    assert(reflectionOwningType instanceof Reflection, "typeDetailsIfUseful(reflectionOwningType, type) called incorrectly");
-    if (type && renderingTypeDetailsIsUseful(reflectionOwningType, type, context.options.getValue("notRenderedTags"))) {
-        return context.typeDetails(reflectionOwningType, type, false);
-    }
-}
-function highlightedPropertyDetails(context, highlighted) {
-    if (!highlighted?.size)
-        return;
-    return (JSX.createElement("ul", { class: "tsd-parameters" }, Array.from(highlighted.entries(), ([name, parts]) => {
-        return (JSX.createElement("li", { class: "tsd-parameter" },
-            JSX.createElement("h5", null,
-                JSX.createElement("span", null, name)),
-            context.displayParts(parts)));
-    })));
-}
-function highlightedDeclarationDetails(context, declaration, renderAnchors, highlightedProperties) {
-    return (JSX.createElement("ul", { class: "tsd-parameters" }, declaration
-        .getProperties()
-        ?.map((child) => highlightedProperties?.has(child.name) &&
-        renderChild(context, child, renderAnchors, highlightedProperties.get(child.name)))));
-}
-function declarationDetails(context, declaration, renderAnchors) {
-    return (JSX.createElement(JSX.Fragment, null,
-        context.commentSummary(declaration),
-        JSX.createElement("ul", { class: "tsd-parameters" },
-            declaration.signatures && (JSX.createElement("li", { class: "tsd-parameter-signature" },
-                JSX.createElement("ul", { class: classNames({ "tsd-signatures": true }, context.getReflectionClasses(declaration)) }, declaration.signatures.map((item) => {
-                    const anchor = context.router.hasUrl(item) ? context.getAnchor(item) : undefined;
-                    return (JSX.createElement(JSX.Fragment, null,
-                        JSX.createElement("li", { class: "tsd-signature", id: anchor }, context.memberSignatureTitle(item, {
-                            hideName: true,
-                        })),
-                        JSX.createElement("li", { class: "tsd-description" }, context.memberSignatureBody(item, {
-                            hideSources: true,
-                        }))));
-                })))),
-            declaration.indexSignatures?.map((index) => renderIndexSignature(context, index)),
-            declaration.getProperties()?.map((child) => renderChild(context, child, renderAnchors)))));
-}
-function renderChild(context, child, renderAnchors, highlight) {
-    if (child.signatures) {
-        return (JSX.createElement("li", { class: "tsd-parameter" },
-            JSX.createElement("h5", { id: anchorTargetIfPresent(context, child) },
-                child.flags.isRest && JSX.createElement("span", { class: "tsd-signature-symbol" }, "..."),
-                JSX.createElement("span", { class: getKindClass(child) }, child.name),
-                JSX.createElement("span", { class: "tsd-signature-symbol" },
-                    child.flags.isOptional && "?",
-                    ":"),
-                " function"),
-            context.memberSignatures(child)));
-    }
-    function highlightOrComment(refl) {
-        if (highlight) {
-            return context.displayParts(highlight);
-        }
-        return (JSX.createElement(JSX.Fragment, null,
-            context.commentSummary(refl),
-            context.commentTags(refl)));
-    }
-    // standard type
-    if (child.type) {
-        const notRenderedTags = context.options.getValue("notRenderedTags");
-        return (JSX.createElement("li", { class: "tsd-parameter" },
-            JSX.createElement("h5", { id: anchorTargetIfPresent(context, child) },
-                context.reflectionFlags(child),
-                child.flags.isRest && JSX.createElement("span", { class: "tsd-signature-symbol" }, "..."),
-                JSX.createElement("span", { class: getKindClass(child) }, child.name),
-                JSX.createElement("span", { class: "tsd-signature-symbol" },
-                    child.flags.isOptional && "?",
-                    ": "),
-                context.type(child.type)),
-            highlightOrComment(child),
-            child.getProperties().some(prop => renderingChildIsUseful(prop, notRenderedTags)) && (JSX.createElement("ul", { class: "tsd-parameters" }, child.getProperties().map((c) => renderChild(context, c, renderAnchors))))));
-    }
-    // getter/setter
-    return (JSX.createElement(JSX.Fragment, null,
-        child.getSignature && (JSX.createElement("li", { class: "tsd-parameter" },
-            JSX.createElement("h5", { id: anchorTargetIfPresent(context, child) },
-                context.reflectionFlags(child.getSignature),
-                JSX.createElement("span", { class: "tsd-signature-keyword" }, "get"),
-                " ",
-                JSX.createElement("span", { class: getKindClass(child) }, child.name),
-                JSX.createElement("span", { class: "tsd-signature-symbol" }, "():"),
-                " ",
-                context.type(child.getSignature.type)),
-            highlightOrComment(child.getSignature))),
-        child.setSignature && (JSX.createElement("li", { class: "tsd-parameter" },
-            JSX.createElement("h5", { id: !child.getSignature ? anchorTargetIfPresent(context, child) : undefined },
-                context.reflectionFlags(child.setSignature),
-                JSX.createElement("span", { class: "tsd-signature-keyword" }, "set"),
-                " ",
-                JSX.createElement("span", { class: getKindClass(child) }, child.name),
-                JSX.createElement("span", { class: "tsd-signature-symbol" }, "("),
-                child.setSignature.parameters?.map((item) => (JSX.createElement(JSX.Fragment, null,
-                    item.name,
-                    JSX.createElement("span", { class: "tsd-signature-symbol" }, ":"),
-                    " ",
-                    context.type(item.type)))),
-                JSX.createElement("span", { class: "tsd-signature-symbol" }, "):"),
-                " ",
-                context.type(child.setSignature.type)),
-            highlightOrComment(child.setSignature)))));
-}
-function renderIndexSignature(context, index) {
-    return (JSX.createElement("li", { class: "tsd-parameter-index-signature" },
-        JSX.createElement("h5", null,
-            index.flags.isReadonly && (JSX.createElement(JSX.Fragment, null,
-                JSX.createElement("span", { class: "tsd-signature-keyword" }, "readonly"),
-                " ")),
-            JSX.createElement("span", { class: "tsd-signature-symbol" }, "["),
-            index.parameters.map((item) => (JSX.createElement(JSX.Fragment, null,
-                JSX.createElement("span", { class: getKindClass(item) }, item.name),
-                ": ",
-                context.type(item.type)))),
-            JSX.createElement("span", { class: "tsd-signature-symbol" }, "]:"),
-            " ",
-            context.type(index.type)),
-        context.commentSummary(index),
-        context.commentTags(index),
-        context.typeDeclaration(index, index.type)));
-}
-function renderingChildIsUseful(refl, notRenderedTags) {
-    // Object types directly under a variable/type alias will always be considered useful.
-    // This probably isn't ideal, but it is an easy thing to check when assigning URLs
-    // in the default theme, so we'll make the assumption that those properties ought to always
-    // be rendered.
-    // This should be kept in sync with the DefaultTheme.applyAnchorUrl function.
-    if (refl.kindOf(ReflectionKind.TypeLiteral) &&
-        refl.parent?.kindOf(ReflectionKind.SomeExport) &&
-        refl.parent.type?.type === "reflection") {
-        return true;
-    }
-    if (renderingThisChildIsUseful(refl, notRenderedTags)) {
-        return true;
-    }
-    return refl.getProperties().some(prop => renderingThisChildIsUseful(prop, notRenderedTags));
-}
-function renderingThisChildIsUseful(refl, notRenderedTags) {
-    if (refl.hasComment(notRenderedTags))
-        return true;
-    const declaration = refl.type?.type === "reflection" ? refl.type.declaration : refl;
-    if (declaration.hasComment(notRenderedTags))
-        return true;
-    return declaration.getAllSignatures().some((sig) => {
-        return sig.hasComment(notRenderedTags) || sig.parameters?.some((p) => p.hasComment(notRenderedTags));
-    });
-}

package/dist/lib/output/themes/default/partials/typeParameters.js

@@ -1,26 +0,0 @@
-import { i18n, JSX } from "#utils";
-import { anchorTargetIfPresent } from "./anchor-icon.js";
-export function typeParameters(context, typeParameters) {
-    return (JSX.createElement(JSX.Fragment, null,
-        JSX.createElement("section", { class: "tsd-panel" },
-            JSX.createElement("h4", null, i18n.kind_plural_type_parameter()),
-            JSX.createElement("ul", { class: "tsd-type-parameter-list" }, typeParameters.map((item) => (JSX.createElement("li", null,
-                JSX.createElement("span", { id: anchorTargetIfPresent(context, item) },
-                    item.flags.isConst && (JSX.createElement(JSX.Fragment, null,
-                        JSX.createElement("span", { class: "tsd-signature-keyword" }, "const"),
-                        " ")),
-                    item.varianceModifier && (JSX.createElement(JSX.Fragment, null,
-                        JSX.createElement("span", { class: "tsd-signature-keyword" }, item.varianceModifier),
-                        " ")),
-                    JSX.createElement("span", { class: "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))),
-                    !!item.default && (JSX.createElement(JSX.Fragment, null,
-                        " = ",
-                        context.type(item.default)))),
-                context.commentSummary(item),
-                context.commentTags(item))))))));
-}

package/dist/lib/output/themes/default/templates/document.js

@@ -1,3 +0,0 @@
-import { JSX } from "#utils";
-export const documentTemplate = ({ markdown }, props) => (JSX.createElement("div", { class: "tsd-panel tsd-typography" },
-    JSX.createElement(JSX.Raw, { html: markdown(props.model.content) })));

package/dist/lib/output/themes/default/templates/hierarchy.js

@@ -1,31 +0,0 @@
-import { i18n, JSX } from "#utils";
-import { getHierarchyRoots } from "../../lib.js";
-function fullHierarchy(context, root, seen) {
-    if (seen.has(root)) {
-        return (JSX.createElement("li", { "data-refl": root.id },
-            JSX.createElement("a", { href: context.urlTo(root) },
-                context.reflectionIcon(root),
-                root.name)));
-    }
-    seen.add(root);
-    const children = [];
-    for (const child of [...(root.implementedBy || []), ...(root.extendedBy || [])]) {
-        if (child.reflection) {
-            children.push(fullHierarchy(context, child.reflection, seen));
-        }
-    }
-    // Note: We don't use root.anchor for the anchor, because those are built on a per page basis.
-    // And classes/interfaces get their own page, so all the anchors will be empty anyways.
-    // Full name should be safe here, since this list only includes classes/interfaces.
-    return (JSX.createElement("li", { "data-refl": root.id, id: root.getFullName() },
-        JSX.createElement("a", { href: context.urlTo(root) },
-            context.reflectionIcon(root),
-            root.name),
-        !!children.length && JSX.createElement("ul", null, children)));
-}
-export function hierarchyTemplate(context, props) {
-    const seen = new Set();
-    return (JSX.createElement(JSX.Fragment, null,
-        JSX.createElement("h2", null, i18n.theme_hierarchy_summary()),
-        getHierarchyRoots(props.project).map((root) => (JSX.createElement("ul", { class: "tsd-full-hierarchy" }, fullHierarchy(context, root, seen))))));
-}

package/dist/lib/output/themes/default/templates/index.js

@@ -1,3 +0,0 @@
-import { JSX } from "#utils";
-export const indexTemplate = ({ markdown }, props) => (JSX.createElement("div", { class: "tsd-panel tsd-typography" },
-    JSX.createElement(JSX.Raw, { html: markdown(props.model.readme || []) })));

package/dist/lib/output/themes/default/templates/reflection.js

@@ -1,53 +0,0 @@
-import { classNames, getKindClass, hasTypeParameters } from "../../lib.js";
-import { DeclarationReflection, ReflectionKind, } from "../../../../models/index.js";
-import { i18n, JSX } from "#utils";
-export function reflectionTemplate(context, props) {
-    if (props.model.kindOf(ReflectionKind.TypeAlias | ReflectionKind.Variable) &&
-        props.model instanceof DeclarationReflection &&
-        props.model.type) {
-        return context.memberDeclaration(props.model);
-    }
-    if (props.model.kindOf(ReflectionKind.ExportContainer) &&
-        (props.model.isDeclaration() || props.model.isProject())) {
-        return context.moduleReflection(props.model);
-    }
-    return (JSX.createElement(JSX.Fragment, null,
-        props.model.hasComment(context.options.getValue("notRenderedTags")) && (JSX.createElement("section", { class: "tsd-panel tsd-comment" },
-            context.commentSummary(props.model),
-            context.commentTags(props.model))),
-        context.reflectionPreview(props.model),
-        hasTypeParameters(props.model) && JSX.createElement(JSX.Fragment, null, context.typeParameters(props.model.typeParameters)),
-        props.model instanceof DeclarationReflection && (JSX.createElement(JSX.Fragment, null,
-            context.hierarchy(props.model.typeHierarchy),
-            !!props.model.implementedTypes && (JSX.createElement("section", { class: "tsd-panel" },
-                JSX.createElement("h4", null, i18n.theme_implements()),
-                JSX.createElement("ul", { class: "tsd-hierarchy" }, props.model.implementedTypes.map((item) => JSX.createElement("li", null, context.type(item)))))),
-            !!props.model.implementedBy && (JSX.createElement("section", { class: "tsd-panel" },
-                JSX.createElement("h4", null, i18n.theme_implemented_by()),
-                JSX.createElement("ul", { class: "tsd-hierarchy" }, props.model.implementedBy.map((item) => JSX.createElement("li", null, context.type(item)))))),
-            !!props.model.signatures?.length && (JSX.createElement("section", { class: "tsd-panel" }, context.memberSignatures(props.model))),
-            !!props.model.indexSignatures?.length && (JSX.createElement("section", { class: "tsd-panel" },
-                JSX.createElement("h4", { class: "tsd-before-signature" }, i18n.theme_indexable()),
-                JSX.createElement("ul", { class: "tsd-signatures" }, props.model.indexSignatures.map((index) => renderIndexSignature(context, index))))),
-            !props.model.signatures && context.memberSources(props.model))),
-        !!props.model.childrenIncludingDocuments?.length && context.index(props.model),
-        context.members(props.model)));
-}
-function renderIndexSignature(context, index) {
-    return (JSX.createElement("li", { class: classNames({ "tsd-index-signature": true }, context.getReflectionClasses(index)) },
-        JSX.createElement("div", { class: "tsd-signature" },
-            index.flags.isReadonly && (JSX.createElement(JSX.Fragment, null,
-                JSX.createElement("span", { class: "tsd-signature-keyword" }, "readonly"),
-                " ")),
-            JSX.createElement("span", { class: "tsd-signature-symbol" }, "["),
-            index.parameters.map((item) => (JSX.createElement(JSX.Fragment, null,
-                JSX.createElement("span", { class: getKindClass(item) }, item.name),
-                ": ",
-                context.type(item.type)))),
-            JSX.createElement("span", { class: "tsd-signature-symbol" }, "]:"),
-            " ",
-            context.type(index.type)),
-        context.commentSummary(index),
-        context.commentTags(index),
-        context.typeDetailsIfUseful(index, index.type)));
-}