@gtkx/codegen 1.0.0-rc.3 → 1.0.0

package/src/docs/handwritten-props.ts

@@ -0,0 +1,230 @@
+import type { ModuleExport } from "@gtkx/react/config";
+import { fileURLToPath } from "node:url";
+import ts from "typescript";
+
+type HandwrittenProp = {
+    name: string;
+    type: string;
+    doc: string;
+};
+
+type AliasSite = {
+    sourceFile: ts.SourceFile;
+    declaration: ts.TypeAliasDeclaration;
+};
+
+type NamedBinding = ts.ImportSpecifier | ts.ExportSpecifier;
+
+const RESOLUTION_OPTIONS: ts.CompilerOptions = {
+    moduleResolution: ts.ModuleResolutionKind.Bundler,
+    customConditions: ["source"],
+};
+
+const CONTAINING_FILE = fileURLToPath(import.meta.url);
+const WHITESPACE_RUN = /\s+/g;
+const propsByRef: Map<string, HandwrittenProp[]> = new Map();
+
+const moduleFileFor = (specifier: string, containingFile: string): string | undefined =>
+    ts.resolveModuleName(specifier, containingFile, RESOLUTION_OPTIONS, ts.sys).resolvedModule?.resolvedFileName;
+
+const parseModule = (filePath: string): ts.SourceFile =>
+    ts.createSourceFile(filePath, ts.sys.readFile(filePath) ?? "", ts.ScriptTarget.Latest, true);
+
+const specifierText = (node: ts.Expression | undefined): string | undefined =>
+    node !== undefined && ts.isStringLiteral(node) ? node.text : undefined;
+
+const boundName = (elements: readonly NamedBinding[], name: string): string | undefined => {
+    for (const element of elements) {
+        if (element.name.text === name) {
+            return (element.propertyName ?? element.name).text;
+        }
+    }
+
+    return undefined;
+};
+
+const findAliasInModule = (specifier: string, sourceFile: ts.SourceFile, name: string): AliasSite | undefined => {
+    const filePath = moduleFileFor(specifier, sourceFile.fileName);
+
+    return filePath === undefined ? undefined : findAlias(parseModule(filePath), name);
+};
+
+const importedAlias = (
+    statement: ts.ImportDeclaration,
+    sourceFile: ts.SourceFile,
+    name: string,
+): AliasSite | undefined => {
+    const bindings = statement.importClause?.namedBindings;
+    const specifier = specifierText(statement.moduleSpecifier);
+
+    if (specifier === undefined || bindings === undefined || !ts.isNamedImports(bindings)) {
+        return undefined;
+    }
+
+    const imported = boundName(bindings.elements, name);
+
+    return imported === undefined ? undefined : findAliasInModule(specifier, sourceFile, imported);
+};
+
+const exportedAlias = (
+    statement: ts.ExportDeclaration,
+    sourceFile: ts.SourceFile,
+    name: string,
+): AliasSite | undefined => {
+    const specifier = specifierText(statement.moduleSpecifier);
+
+    if (specifier === undefined) {
+        return undefined;
+    }
+
+    const clause = statement.exportClause;
+
+    if (clause === undefined) {
+        return findAliasInModule(specifier, sourceFile, name);
+    }
+
+    const exported = ts.isNamedExports(clause) ? boundName(clause.elements, name) : undefined;
+
+    return exported === undefined ? undefined : findAliasInModule(specifier, sourceFile, exported);
+};
+
+const statementAlias = (statement: ts.Statement, sourceFile: ts.SourceFile, name: string): AliasSite | undefined => {
+    if (ts.isTypeAliasDeclaration(statement)) {
+        return statement.name.text === name ? { sourceFile, declaration: statement } : undefined;
+    }
+
+    if (ts.isImportDeclaration(statement)) {
+        return importedAlias(statement, sourceFile, name);
+    }
+
+    return ts.isExportDeclaration(statement) ? exportedAlias(statement, sourceFile, name) : undefined;
+};
+
+const propType = (type: ts.TypeNode, sourceFile: ts.SourceFile): string => {
+    const parts: readonly ts.TypeNode[] = ts.isUnionTypeNode(type) ? type.types : [type];
+
+    return parts
+        .filter((part) => part.kind !== ts.SyntaxKind.UndefinedKeyword)
+        .map((part) => part.getText(sourceFile).replaceAll(WHITESPACE_RUN, " "))
+        .join(" | ");
+};
+
+const propDoc = (member: ts.TypeElement): string => {
+    const comments = ts
+        .getJSDocCommentsAndTags(member)
+        .map((node) => (ts.isJSDoc(node) ? ts.getTextOfJSDocComment(node.comment) : undefined));
+
+    return comments.filter((text) => text !== undefined).join(" ").replaceAll(WHITESPACE_RUN, " ").trim();
+};
+
+const propertyProp = (member: ts.PropertySignature, sourceFile: ts.SourceFile): HandwrittenProp | undefined => {
+    const { name, type } = member;
+
+    if (type === undefined || !(ts.isIdentifier(name) || ts.isStringLiteral(name))) {
+        return undefined;
+    }
+
+    return { name: name.text, type: propType(type, sourceFile), doc: propDoc(member) };
+};
+
+const indexProp = (member: ts.IndexSignatureDeclaration, sourceFile: ts.SourceFile): HandwrittenProp | undefined => {
+    const keyType = member.parameters[0]?.type;
+
+    if (keyType === undefined) {
+        return undefined;
+    }
+
+    return {
+        name: keyType.getText(sourceFile).replaceAll("`", ""),
+        type: propType(member.type, sourceFile),
+        doc: propDoc(member),
+    };
+};
+
+const memberProp = (member: ts.TypeElement, sourceFile: ts.SourceFile): HandwrittenProp | undefined => {
+    if (ts.isPropertySignature(member)) {
+        return propertyProp(member, sourceFile);
+    }
+
+    return ts.isIndexSignatureDeclaration(member) ? indexProp(member, sourceFile) : undefined;
+};
+
+const literalProps = (type: ts.TypeLiteralNode, sourceFile: ts.SourceFile): HandwrittenProp[] => {
+    const props: HandwrittenProp[] = [];
+
+    for (const member of type.members) {
+        const prop = memberProp(member, sourceFile);
+
+        if (prop !== undefined) {
+            props.push(prop);
+        }
+    }
+
+    return props;
+};
+
+const referenceProps = (type: ts.TypeReferenceNode, sourceFile: ts.SourceFile): HandwrittenProp[] => {
+    if (!ts.isIdentifier(type.typeName)) {
+        return [];
+    }
+
+    const site = findAlias(sourceFile, type.typeName.text);
+
+    return site === undefined ? [] : typeNodeProps(site.declaration.type, site.sourceFile);
+};
+
+const declaredProps = (ref: ModuleExport): HandwrittenProp[] => {
+    const filePath = moduleFileFor(ref.module, CONTAINING_FILE);
+
+    if (filePath === undefined) {
+        throw new Error(`Cannot resolve ${ref.module}, which declares the ${ref.export} element props`);
+    }
+
+    const site = findAlias(parseModule(filePath), ref.export);
+
+    if (site === undefined) {
+        throw new Error(`${ref.module} declares no type named ${ref.export}`);
+    }
+
+    return typeNodeProps(site.declaration.type, site.sourceFile);
+};
+
+const handwrittenPropsFor = (ref: ModuleExport): HandwrittenProp[] => {
+    const key = `${ref.module}#${ref.export}`;
+    const cached = propsByRef.get(key);
+
+    if (cached !== undefined) {
+        return cached;
+    }
+
+    const props = declaredProps(ref);
+    propsByRef.set(key, props);
+
+    return props;
+};
+
+function findAlias(sourceFile: ts.SourceFile, name: string): AliasSite | undefined {
+    for (const statement of sourceFile.statements) {
+        const site = statementAlias(statement, sourceFile, name);
+
+        if (site !== undefined) {
+            return site;
+        }
+    }
+
+    return undefined;
+}
+
+function typeNodeProps(type: ts.TypeNode, sourceFile: ts.SourceFile): HandwrittenProp[] {
+    if (ts.isTypeLiteralNode(type)) {
+        return literalProps(type, sourceFile);
+    }
+
+    if (ts.isIntersectionTypeNode(type)) {
+        return type.types.flatMap((part) => typeNodeProps(part, sourceFile));
+    }
+
+    return ts.isTypeReferenceNode(type) ? referenceProps(type, sourceFile) : [];
+}
+
+export { handwrittenPropsFor, type HandwrittenProp };

package/src/docs/pipeline.ts

@@ -7,7 +7,7 @@ import { namespaceDirectory } from "../gir/namespace.js";
 import { type ElementProps, setElementProps } from "../store/jsx/element-prop-imports.js";
 import { collectIntrinsicElementClasses, type GlibNamedClass } from "../store/jsx/intrinsic-elements.js";
 import { type OmittedProps, setOmittedProps } from "../store/jsx/omitted-props.js";
-import { createElementPageContext, type ElementPageContext, renderElementPage } from "./element-page.js";
+import { type ElementPageContext, renderElementPage } from "./element-page.js";
 import { elementSlug, firstSentence, namespaceOrder } from "./render.js";
 
 type DocsElementLink = {
@@ -28,8 +28,8 @@ type DocsOptions = {
     outDir: string;
     basePath?: string;
     props?: ElementProps;
-    omitProps?: OmittedProps;
-    force?: boolean;
+    omittedProps?: OmittedProps;
+    isForced?: boolean;
 };
 
 type DocsManifest = {
@@ -45,7 +45,7 @@ type Page = { path: string; content: string };
 type NamespacePages = { docs: DocsNamespace; pages: Page[] };
 
 type DocsResult = {
-    regenerated: boolean;
+    isRegenerated: boolean;
     namespaces: DocsNamespace[];
 };
 
@@ -175,7 +175,7 @@ const generatePages = (options: DocsOptions, basePath: string, library: Library)
     const intrinsicElements = collectIntrinsicElementClasses(library);
     const byNamespace = groupElementsByNamespace(intrinsicElements);
     const linkByGlibName = buildElementLinks(intrinsicElements, basePath);
-    const pageContext = createElementPageContext(library, (glibName: string) => linkByGlibName.get(glibName));
+    const pageContext: ElementPageContext = { library, linkFor: (glibName) => linkByGlibName.get(glibName) };
     const pages: Page[] = [];
     const namespaces: DocsNamespace[] = [];
     const orderedNames = sortStringsBy(byNamespace.keys(), namespaceOrder);
@@ -193,7 +193,7 @@ const generatePages = (options: DocsOptions, basePath: string, library: Library)
 };
 
 const cachedDocsResult = (options: DocsOptions, manifestPath: string): DocsResult | undefined => {
-    if (options.force === true || !isGiStoreFresh(options.outDir, options.libraries, options.girPath)) {
+    if (options.isForced === true || !isGiStoreFresh(options.outDir, options.libraries, options.girPath)) {
         return undefined;
     }
 
@@ -203,7 +203,7 @@ const cachedDocsResult = (options: DocsOptions, manifestPath: string): DocsResul
 
     const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as DocsManifest;
 
-    return { regenerated: false, namespaces: manifest.namespaces };
+    return { isRegenerated: false, namespaces: manifest.namespaces };
 };
 
 const writePages = (outDir: string, pages: Page[]): void => {
@@ -216,7 +216,7 @@ const writePages = (outDir: string, pages: Page[]): void => {
 
 const writeDocs = (options: DocsOptions): DocsResult => {
     setElementProps(options.props ?? {});
-    setOmittedProps(options.omitProps ?? {});
+    setOmittedProps(options.omittedProps ?? {});
     const basePath = options.basePath ?? "/reference";
     const manifestPath = join(options.outDir, MANIFEST_FILENAME);
     const cached = cachedDocsResult(options, manifestPath);
@@ -238,7 +238,7 @@ const writeDocs = (options: DocsOptions): DocsResult => {
         JSON.stringify(computeGiFingerprint(library.girFiles, options.libraries, options.girPath)),
     );
 
-    return { regenerated: true, namespaces };
+    return { isRegenerated: true, namespaces };
 };
 
-export { writeDocs, type DocsElementLink, type DocsNamespace, type DocsOptions, type DocsResult };
+export { writeDocs };

package/src/docs/render.ts

@@ -1,31 +1,57 @@
 import { pascalCase, sortStringsBy } from "@gtkx/utils";
+import type { GirAnnotations } from "../gir/annotations.js";
 import type { GirClass } from "../gir/class.js";
 import type { GirFunction } from "../gir/function.js";
 import type { Library } from "../gir/library.js";
 import type { GirNamespace } from "../gir/namespace.js";
 import type { GirCallable } from "../gir/parameter.js";
+import type { GirProperty } from "../gir/property.js";
 import type { TypeId } from "../gir/type-id.js";
+import type { JsDocDeprecation, JsDocParam, JsDocSpec } from "../writer/doc-tags.js";
 import { collectInheritedMethods, conflictRename } from "../analysis/inheritance.js";
 import { renderHandlerParameters, renderHandlerResultType } from "../analysis/param-structure.js";
 import { recordTypeTarget, renderBaseType, type TsTypeTarget } from "../analysis/ts-type.js";
-import { dedupeCallables, instanceScope, renderInstanceMethodSignature } from "../store/gi/callables.js";
+import {
+    dedupeCallables,
+    instanceMemberSpec,
+    instanceScope,
+    renderInstanceMethodSignature,
+} from "../store/gi/callables.js";
+import { annotationSpec, handlerSpec, selfHandlerSpec } from "../store/gi/doc-spec.js";
 import { methodExportName } from "../store/gi/method.js";
 import { ModuleContext } from "../writer/context.js";
+import { stripDocMedia } from "../writer/doc-tags.js";
 import { gtkDocToMarkdown } from "../writer/gtk-doc.js";
 
 type SignatureEntry = {
     name: string;
     signature: string;
     doc: string;
+    tags?: JsDocSpec | undefined;
 };
 
 type OriginSignatureEntry = SignatureEntry & { origin: string | undefined };
 
+type MetaDocEntry = {
+    name: string;
+    meta: string;
+    doc: string;
+    tags?: JsDocSpec | undefined;
+};
+
+type PropertyMetaOptions = {
+    type: string;
+    property: GirProperty;
+    accessNotes: string[];
+    origin: string | undefined;
+};
+
 const DOCS_DEFAULT_VALUES: Record<string, string> = { TRUE: "true", FALSE: "false", NULL: "null" };
 const FENCE_LINE = /^\s*(```|~~~)/;
 const HEADING_LINE = /^#{1,5}\s/;
 const LEADING_NAMESPACES = ["Gtk", "Adw"];
 const DOCS_SIGNATURE_NAMESPACE = "$docs";
+const WHITESPACE_RUN = /\s+/g;
 
 const docsTarget = (library: Library): TsTypeTarget =>
     recordTypeTarget(
@@ -45,8 +71,8 @@ const renderDocsHandlerResultType = (library: Library, signal: GirCallable): str
         library,
         signal,
         renderType: (ref, nullable) => renderDocsType(library, ref, nullable),
-        includeCallerAllocated: false,
-        optOut: true,
+        shouldIncludeCallerAllocated: false,
+        isOptOut: true,
     });
 
 const renderDocsHandlerParameters = (library: Library, signal: GirCallable): string[] =>
@@ -63,22 +89,16 @@ const renderDocsSignalHandlerType = (library: Library, signal: GirCallable): str
 
 const docsDefaultValue = (value: string): string => DOCS_DEFAULT_VALUES[value] ?? value;
 
-const stripDocMedia = (markdown: string): string =>
-    markdown
-        .replaceAll(/<picture[\s\S]*?<\/picture>/g, "")
-        .replaceAll(/<video[\s\S]*?(?:<\/video>|\/>)/g, "")
-        .replaceAll(/<img[^>]*>/g, "");
-
-const demoteLine = (line: string, isInFence: boolean): { text: string; inFence: boolean } => {
+const demoteLine = (line: string, isInFence: boolean): { text: string; isInFence: boolean } => {
     if (FENCE_LINE.test(line)) {
-        return { text: line, inFence: !isInFence };
+        return { text: line, isInFence: !isInFence };
     }
 
     if (isInFence) {
-        return { text: line, inFence: isInFence };
+        return { text: line, isInFence };
     }
 
-    return { text: HEADING_LINE.test(line) ? `#${line}` : line, inFence: isInFence };
+    return { text: HEADING_LINE.test(line) ? `#${line}` : line, isInFence };
 };
 
 const demoteHeadings = (markdown: string): string => {
@@ -87,7 +107,7 @@ const demoteHeadings = (markdown: string): string => {
 
     for (const line of markdown.split("\n")) {
         const result = demoteLine(line, isInFence);
-        isInFence = result.inFence;
+        isInFence = result.isInFence;
         lines.push(result.text);
     }
 
@@ -102,12 +122,15 @@ const stripMarkdown = (markdown: string): string =>
         .replaceAll(/```[\s\S]*?```/g, " ")
         .replaceAll(/`([^`]*)`/g, "$1")
         .replaceAll(/\[([^[\]]*)\]\([^)]*\)/g, "$1")
-        .replaceAll(/[*_#>]/g, "")
-        .replaceAll(/\s+/g, " ")
+        .replaceAll(/[*#>]/g, "")
+        .replaceAll(WHITESPACE_RUN, " ")
         .trim();
 
+const inlineMarkdown = (doc: string | undefined): string => docMarkdown(doc).replaceAll(WHITESPACE_RUN, " ").trim();
+const plainText = (doc: string | undefined): string => stripMarkdown(docMarkdown(doc));
+
 const firstSentence = (doc: string | undefined): string => {
-    const text = stripMarkdown(docMarkdown(doc));
+    const text = plainText(doc);
 
     if (text.length === 0) {
         return "";
@@ -138,16 +161,102 @@ const implementsLine = (names: string[]): string[] => {
 const joinSections = (sections: string[]): string =>
     `${sections.filter((section) => section.length > 0).join("\n\n")}\n`;
 
-const metaBlock = (name: string, meta: string, doc: string): string => {
-    const lines = [`### \`${name}\``, "", meta];
+const paramNotes = (params: JsDocParam[] | undefined): string[] => {
+    const entries = (params ?? [])
+        .map((param) => ({ name: param.name, text: inlineMarkdown(param.doc) }))
+        .filter((entry) => entry.text.length > 0);
+
+    if (entries.length === 0) {
+        return [];
+    }
+
+    const bullets = entries.map((entry) => `- \`${entry.name}\`: ${entry.text}`);
+
+    return [["**Parameters**", "", ...bullets].join("\n")];
+};
+
+const labelledNote = (label: string, text: string): string[] => (text.length === 0 ? [] : [`${label} ${text}`]);
+
+const deprecationNote = (deprecation: JsDocDeprecation | undefined): string[] => {
+    if (deprecation === undefined) {
+        return [];
+    }
+
+    const since = deprecation.since;
+    const heading = since === undefined ? "**Deprecated.**" : `**Deprecated since ${since}.**`;
+    const text = inlineMarkdown(deprecation.doc);
+    const body = text.length === 0 ? heading : `${heading} ${text}`;
+
+    return [`> ${body}`];
+};
+
+const sinceNote = (since: string | undefined): string[] =>
+    since === undefined || since.length === 0 ? [] : [`_Available since ${since}._`];
+
+const tagNotes = (spec: JsDocSpec | undefined): string[] => {
+    if (spec === undefined) {
+        return [];
+    }
+
+    return [
+        ...paramNotes(spec.params),
+        ...labelledNote("**Returns**", docMarkdown(spec.returns)),
+        ...labelledNote("**Throws**", inlineMarkdown(spec.throws)),
+        ...deprecationNote(spec.deprecated),
+        ...sinceNote(spec.since),
+    ];
+};
+
+const deprecationMeta = (annotations: GirAnnotations): string[] => {
+    if (!annotations.isDeprecated) {
+        return [];
+    }
+
+    const since = annotations.deprecatedSince;
+
+    return [since === undefined ? "deprecated" : `deprecated since ${since}`];
+};
+
+const annotationNotes = (annotations: GirAnnotations): string[] => tagNotes(annotationSpec(annotations));
 
-    if (doc.length > 0) {
-        lines.push("", doc);
+const signalTags = (signal: GirCallable, isSelfIncluded: boolean): JsDocSpec =>
+    isSelfIncluded ? selfHandlerSpec(signal) : handlerSpec(signal, signal.parameters);
+
+const metaBlock = (entry: MetaDocEntry): string => {
+    const lines = [`### \`${entry.name}\``, "", entry.meta];
+
+    for (const note of [entry.doc, ...tagNotes(entry.tags)]) {
+        if (note.length > 0) {
+            lines.push("", note);
+        }
     }
 
     return lines.join("\n");
 };
 
+const sortedMetaBlocks = (entries: MetaDocEntry[]): string[] =>
+    sortStringsBy(entries, (item) => item.name).map((item) => metaBlock(item));
+
+const propertyMetaLine = ({ type, property, accessNotes, origin }: PropertyMetaOptions): string => {
+    const meta = [`\`${type}\``];
+
+    if (property.defaultValue !== undefined) {
+        meta.push(`default \`${docsDefaultValue(property.defaultValue)}\``);
+    }
+
+    if (property.constructOnly) {
+        meta.push("construct-only");
+    }
+
+    meta.push(...accessNotes, ...deprecationMeta(property.annotations));
+
+    if (origin !== undefined) {
+        meta.push(`from \`${origin}\``);
+    }
+
+    return meta.join(" · ");
+};
+
 const signatureBlock = (name: string, signature: string, notes: string[]): string => {
     const lines = [`### \`${name}\``, "", `\`\`\`ts\n${signature}\n\`\`\``];
 
@@ -160,6 +269,9 @@ const signatureBlock = (name: string, signature: string, notes: string[]): strin
     return lines.join("\n");
 };
 
+const signatureEntryBlock = (entry: SignatureEntry, leadingNotes: string[] = []): string =>
+    signatureBlock(entry.name, entry.signature, [...leadingNotes, entry.doc, ...tagNotes(entry.tags)]);
+
 const namespaceOrder = (name: string): string => {
     const index = LEADING_NAMESPACES.indexOf(name);
 
@@ -171,10 +283,7 @@ const docsSignatureContext = (namespace: GirNamespace, library: Library): Module
 
 const originSignatureBlocks = (entries: OriginSignatureEntry[]): string[] =>
     sortStringsBy(entries, (item) => item.name).map((item) =>
-        signatureBlock(item.name, item.signature, [
-            item.origin === undefined ? "" : `From \`${item.origin}\`.`,
-            item.doc,
-        ]),
+        signatureEntryBlock(item, item.origin === undefined ? [] : [`From \`${item.origin}\`.`]),
     );
 
 const classMethodEntries = (library: Library, namespace: GirNamespace, klass: GirClass): SignatureEntry[] => {
@@ -189,9 +298,7 @@ const classMethodEntries = (library: Library, namespace: GirNamespace, klass: Gi
 };
 
 const methodsSectionBlocks = (entries: SignatureEntry[], intro: string): string[] =>
-    entries.length === 0
-        ? []
-        : ["## Methods", intro, ...entries.map((item) => signatureBlock(item.name, item.signature, [item.doc]))];
+    entries.length === 0 ? [] : ["## Methods", intro, ...entries.map((item) => signatureEntryBlock(item))];
 
 const instanceMethodEntries = (
     signatureContext: ModuleContext,
@@ -210,13 +317,7 @@ const instanceMethodEntries = (
 
     for (const method of deduped) {
         const nameOverride = rename(method);
-
-        const rendered = renderInstanceMethodSignature(
-            signatureContext,
-            { ...method, doc: undefined },
-            scope,
-            nameOverride,
-        );
+        const rendered = renderInstanceMethodSignature(signatureContext, method, scope, nameOverride);
 
         if (rendered === undefined) {
             continue;
@@ -224,32 +325,45 @@ const instanceMethodEntries = (
 
         entries.push({
             name: nameOverride ?? methodExportName(method),
-            signature: rendered.trim().replace(/;$/, ""),
+            signature: signatureText(rendered),
             doc: docMarkdown(method.doc),
+            tags: instanceMemberSpec(signatureContext, method, scope),
         });
     }
 
     return sortStringsBy(entries, (entry) => entry.name);
 };
 
+const signatureText = (rendered: string): string => {
+    const start = rendered.startsWith("/**") ? rendered.indexOf("*/") + 2 : 0;
+
+    return rendered.slice(start).trim().replace(/;$/, "");
+};
+
 export {
     renderDocsType,
     renderDocsSignalSignature,
     renderDocsSignalHandlerType,
-    docsDefaultValue,
+    annotationNotes,
+    deprecationMeta,
     docMarkdown,
     firstSentence,
     elementSlug,
     implementsLine,
     joinSections,
-    metaBlock,
+    plainText,
+    propertyMetaLine,
+    signalTags,
     signatureBlock,
+    signatureEntryBlock,
+    sortedMetaBlocks,
     namespaceOrder,
     docsSignatureContext,
     originSignatureBlocks,
     classMethodEntries,
     methodsSectionBlocks,
-    instanceMethodEntries,
+    tagNotes,
+    type MetaDocEntry,
     type SignatureEntry,
     type OriginSignatureEntry,
 };