@gtkx/codegen 1.0.0-rc.1 → 1.0.0-rc.2

package/src/docs/pipeline.ts

@@ -1,32 +1,32 @@
+import { sortStringsBy } from "@gtkx/utils";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import type { ElementProp } from "@gtkx/config";
-import { sortStringsBy } from "@gtkx/utils";
-import { computeFingerprint, FINGERPRINT_FILENAME, isStoreFresh } from "../fingerprint.js";
+import { computeGiFingerprint, FINGERPRINT_FILENAME, isGiStoreFresh } from "../fingerprint.js";
 import { Library } from "../gir/library.js";
 import { namespaceDirectory } from "../gir/namespace.js";
-import { collectIntrinsicElementClasses, type GlibNamedClass } from "../store/react/intrinsic-elements.js";
-import { createElementPageContext, renderElementPage } from "./element-page.js";
+import { type ElementProps, setElementProps } from "../store/jsx/element-prop-imports.js";
+import { collectIntrinsicElementClasses, type GlibNamedClass } from "../store/jsx/intrinsic-elements.js";
+import { createElementPageContext, type ElementPageContext, renderElementPage } from "./element-page.js";
 import { elementSlug, firstSentence, namespaceOrder } from "./render.js";
 
-export type DocsElementLink = {
+type DocsElementLink = {
     text: string;
     link: string;
 };
 
-export type DocsNamespace = {
+type DocsNamespace = {
     name: string;
     directory: string;
     link: string;
     elements: DocsElementLink[];
 };
 
-export type DocsOptions = {
+type DocsOptions = {
     libraries: string[];
     girPath: string[];
     outDir: string;
     basePath?: string;
-    elementProps?: Record<string, ElementProp[]>;
+    props?: ElementProps;
     force?: boolean;
 };
 
@@ -34,22 +34,42 @@ type DocsManifest = {
     namespaces: DocsNamespace[];
 };
 
+type GeneratedDocs = {
+    pages: { path: string; content: string }[];
+    namespaces: DocsNamespace[];
+};
+
+type Page = { path: string; content: string };
+type NamespacePages = { docs: DocsNamespace; pages: Page[] };
+
+type DocsResult = {
+    regenerated: boolean;
+    namespaces: DocsNamespace[];
+};
+
 const MANIFEST_FILENAME = "manifest.json";
 
 const namespaceIndexPage = (namespace: DocsNamespace, elements: GlibNamedClass[]): string => {
     const rows = elements.map((entry, index) => {
         const link = namespace.elements[index]?.link ?? "";
-        const description = firstSentence(entry.klass.doc).replaceAll("|", "\\|");
+        const description = firstSentence(entry.klass.doc).replaceAll("|", String.raw`\|`);
+
         return `| [${entry.glibName}](${link}) | ${description} |`;
     });
+
+    const description =
+        `Reference pages for the ${String(namespace.elements.length)} JSX elements in ` +
+        `the ${namespace.name} namespace.`;
+
     return [
         "---",
-        `description: ${JSON.stringify(`Reference pages for the ${namespace.elements.length} JSX elements in the ${namespace.name} namespace.`)}`,
+        `description: ${JSON.stringify(description)}`,
         "---",
         "",
         `# ${namespace.name} elements`,
         "",
-        `Elements in this namespace are imported from \`@gtkx/jsx/${namespace.directory}\`; the matching classes, enums, and functions are imported from \`@gtkx/gi/${namespace.directory}\`.`,
+        `Elements in this namespace are imported from \`@gtkx/jsx/${namespace.directory}\`; the matching ` +
+        `classes, enums, and functions are imported from \`@gtkx/gi/${namespace.directory}\`.`,
         "",
         "| Element | Description |",
         "| --- | --- |",
@@ -60,21 +80,27 @@ const namespaceIndexPage = (namespace: DocsNamespace, elements: GlibNamedClass[]
 
 const rootIndexPage = (namespaces: DocsNamespace[], libraries: string[]): string => {
     const rows = namespaces.map(
-        (ns) => `| [${ns.name}](${ns.link}) | \`@gtkx/jsx/${ns.directory}\` | ${ns.elements.length} |`,
+        (ns) => `| [${ns.name}](${ns.link}) | \`@gtkx/jsx/${ns.directory}\` | ${String(ns.elements.length)} |`,
     );
+
     const librariesList = libraries.map((library) => `\`${library}\``).join(", ");
+
     return [
         "---",
-        `description: "Generated reference documentation for every JSX element in this project's GIR libraries."`,
+        "description: \"Generated reference documentation for every JSX element in this project's GIR libraries.\"",
         "---",
         "",
         "# Element Reference",
         "",
-        `This reference documents every JSX element generated from the GObject-Introspection data for ${librariesList}, together with the namespaces they pull in. It is produced by \`gtkx docs\` using the same pipeline that generates the \`@gtkx/jsx\` and \`@gtkx/gi\` bindings, so every page matches the types your editor sees.`,
+        "This reference documents every JSX element generated from the GObject-Introspection data for " +
+        `${librariesList}, together with the namespaces they pull in. It is produced by \`gtkx docs\` ` +
+        "using the same pipeline that generates the `@gtkx/jsx` and `@gtkx/gi` bindings, so every page " +
+        "matches the types your editor sees.",
         "",
         "Each element page lists:",
         "",
-        "- **Props** derived from GObject properties, plus the element props GTKX adds (such as `children` and named slots), with types, defaults, and upstream documentation.",
+        "- **Props** derived from GObject properties, plus the element props GTKX adds (such as `children` " +
+        "and named slots), with types, defaults, and upstream documentation.",
         "- **Signals** as `on<Signal>` handler props with their exact handler signatures.",
         "- **Methods** available on the underlying instance through the `ref` prop.",
         "",
@@ -87,96 +113,129 @@ const rootIndexPage = (namespaces: DocsNamespace[], libraries: string[]): string
     ].join("\n");
 };
 
-type GeneratedDocs = {
-    pages: { path: string; content: string }[];
-    namespaces: DocsNamespace[];
-};
-
-const generatePages = (options: DocsOptions, basePath: string, library: Library): GeneratedDocs => {
-    const intrinsicElements = collectIntrinsicElementClasses(library);
+const groupElementsByNamespace = (elements: GlibNamedClass[]): Map<string, GlibNamedClass[]> => {
+    const byNamespace: Map<string, GlibNamedClass[]> = new Map();
 
-    const byNamespace = new Map<string, GlibNamedClass[]>();
-    for (const entry of intrinsicElements) {
+    for (const entry of elements) {
         const list = byNamespace.get(entry.namespace.name) ?? [];
         list.push(entry);
         byNamespace.set(entry.namespace.name, list);
     }
 
-    const linkByGlibName = new Map<string, string>();
-    for (const entry of intrinsicElements) {
+    return byNamespace;
+};
+
+const buildElementLinks = (elements: GlibNamedClass[], basePath: string): Map<string, string> => {
+    const linkByGlibName: Map<string, string> = new Map();
+
+    for (const entry of elements) {
         const directory = namespaceDirectory(entry.namespace);
-        const slug = elementSlug(entry.klass.name);
-        const link = `${basePath}/${directory}/${slug}`;
-        const existing = [...linkByGlibName.values()].includes(link);
-        if (existing) throw new Error(`Docs page slug collision for ${entry.glibName} at ${link}`);
+        const link = `${basePath}/${directory}/${elementSlug(entry.klass.name)}`;
+
+        if (linkByGlibName.values().some((existing) => existing === link)) {
+            throw new Error(`Docs page slug collision for ${entry.glibName} at ${link}`);
+        }
+
         linkByGlibName.set(entry.glibName, link);
     }
 
-    const pageContext = createElementPageContext(library, options.elementProps ?? {}, (glibName) =>
-        linkByGlibName.get(glibName),
-    );
+    return linkByGlibName;
+};
 
-    const pages: { path: string; content: string }[] = [];
+const namespacePages = (input: {
+    name: string;
+    elements: GlibNamedClass[];
+    basePath: string;
+    linkByGlibName: Map<string, string>;
+    pageContext: ElementPageContext;
+}): NamespacePages => {
+    const { name, elements, basePath, linkByGlibName, pageContext } = input;
+    const directory = name.toLowerCase();
+
+    const docs: DocsNamespace = {
+        name,
+        directory,
+        link: `${basePath}/${directory}/`,
+        elements: elements.map((entry) => ({ text: entry.glibName, link: linkByGlibName.get(entry.glibName) ?? "" })),
+    };
+
+    const pages: Page[] = elements.map((entry) => ({
+        path: `${directory}/${elementSlug(entry.klass.name)}.md`,
+        content: renderElementPage(entry, pageContext),
+    }));
+
+    pages.push({ path: `${directory}/index.md`, content: namespaceIndexPage(docs, elements) });
+
+    return { docs, pages };
+};
+
+const generatePages = (options: DocsOptions, basePath: string, library: Library): GeneratedDocs => {
+    const intrinsicElements = collectIntrinsicElementClasses(library);
+    const byNamespace = groupElementsByNamespace(intrinsicElements);
+    const linkByGlibName = buildElementLinks(intrinsicElements, basePath);
+    const pageContext = createElementPageContext(library, (glibName: string) => linkByGlibName.get(glibName));
+    const pages: Page[] = [];
     const namespaces: DocsNamespace[] = [];
-    const orderedNames = sortStringsBy([...byNamespace.keys()], namespaceOrder);
+    const orderedNames = sortStringsBy(byNamespace.keys(), namespaceOrder);
+
     for (const name of orderedNames) {
         const elements = sortStringsBy(byNamespace.get(name) ?? [], (entry) => entry.glibName);
-        const directory = name.toLowerCase();
-        const namespaceDocs: DocsNamespace = {
-            name,
-            directory,
-            link: `${basePath}/${directory}/`,
-            elements: elements.map((entry) => ({
-                text: entry.glibName,
-                link: linkByGlibName.get(entry.glibName) ?? "",
-            })),
-        };
-        for (const entry of elements) {
-            const slug = elementSlug(entry.klass.name);
-            pages.push({ path: `${directory}/${slug}.md`, content: renderElementPage(entry, pageContext) });
-        }
-        pages.push({ path: `${directory}/index.md`, content: namespaceIndexPage(namespaceDocs, elements) });
-        namespaces.push(namespaceDocs);
+        const result = namespacePages({ name, elements, basePath, linkByGlibName, pageContext });
+        pages.push(...result.pages);
+        namespaces.push(result.docs);
     }
+
     pages.push({ path: "index.md", content: rootIndexPage(namespaces, options.libraries) });
+
     return { pages, namespaces };
 };
 
-export type DocsResult = {
-    regenerated: boolean;
-    namespaces: DocsNamespace[];
+const cachedDocsResult = (options: DocsOptions, manifestPath: string): DocsResult | undefined => {
+    if (options.force === true || !isGiStoreFresh(options.outDir, options.libraries, options.girPath)) {
+        return undefined;
+    }
+
+    if (!existsSync(manifestPath)) {
+        return undefined;
+    }
+
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as DocsManifest;
+
+    return { regenerated: false, namespaces: manifest.namespaces };
 };
 
-export const writeDocs = (options: DocsOptions): DocsResult => {
+const writePages = (outDir: string, pages: Page[]): void => {
+    for (const page of pages) {
+        const target = join(outDir, page.path);
+        mkdirSync(dirname(target), { recursive: true });
+        writeFileSync(target, page.content);
+    }
+};
+
+const writeDocs = (options: DocsOptions): DocsResult => {
+    setElementProps(options.props ?? {});
     const basePath = options.basePath ?? "/reference";
-    const elementProps = options.elementProps ?? {};
     const manifestPath = join(options.outDir, MANIFEST_FILENAME);
-    if (options.force !== true && isStoreFresh(options.outDir, options.libraries, elementProps)) {
-        if (existsSync(manifestPath)) {
-            const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as DocsManifest;
-            return { regenerated: false, namespaces: manifest.namespaces };
-        }
+    const cached = cachedDocsResult(options, manifestPath);
+
+    if (cached !== undefined) {
+        return cached;
     }
 
     const library = Library.load(options.libraries, options.girPath);
     const { pages, namespaces } = generatePages(options, basePath, library);
-
     rmSync(options.outDir, { recursive: true, force: true });
     mkdirSync(options.outDir, { recursive: true });
-    for (const page of pages) {
-        const target = join(options.outDir, page.path);
-        mkdirSync(dirname(target), { recursive: true });
-        writeFileSync(target, page.content);
-    }
+    writePages(options.outDir, pages);
     const manifest: DocsManifest = { namespaces };
     writeFileSync(manifestPath, JSON.stringify(manifest));
+
     writeFileSync(
         join(options.outDir, FINGERPRINT_FILENAME),
-        JSON.stringify({
-            value: computeFingerprint(library.girFiles, options.libraries, elementProps),
-            girFiles: library.girFiles,
-            libraries: options.libraries,
-        }),
+        JSON.stringify(computeGiFingerprint(library.girFiles, options.libraries, options.girPath)),
     );
+
     return { regenerated: true, namespaces };
 };
+
+export { writeDocs, type DocsElementLink, type DocsNamespace, type DocsOptions, type DocsResult };

package/src/docs/render.ts

@@ -1,39 +1,46 @@
-import { sortStringsBy, toPascalCase } from "@gtkx/utils";
-import { collectInheritedMethods, conflictRename } from "../analysis/inheritance.js";
-import { renderHandlerParameters, renderHandlerResultType } from "../analysis/param-structure.js";
-import { renderBaseTypeFor, type TsTypeTarget } from "../analysis/ts-type.js";
+import { pascalCase, sortStringsBy } from "@gtkx/utils";
 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 { GirSignal } from "../gir/parameter.js";
+import type { GirCallable } from "../gir/parameter.js";
 import type { TypeId } from "../gir/type-id.js";
-import { dedupeCallables, indexMethodsByName, renderInstanceMethodSignature } from "../store/gi/callables.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 { methodExportName } from "../store/gi/method.js";
 import { ModuleContext } from "../writer/context.js";
 import { gtkDocToMarkdown } from "../writer/gtk-doc.js";
 
-const docsTarget = (library: Library): TsTypeTarget => ({
-    containerStyle: "record",
-    callbackType: "((...args: unknown[]) => unknown)",
-    byteArrayAsNumber: false,
-    renderNamed: (resolved, name) => {
-        if (resolved?.kind === "alias") {
-            return resolved.value.target === undefined
-                ? "number"
-                : renderBaseTypeFor(library, docsTarget(library), resolved.value.target);
-        }
-        return `${name.namespaceName}.${name.typeName}`;
-    },
-    renderGtype: () => "GObject.Type",
-});
+type SignatureEntry = {
+    name: string;
+    signature: string;
+    doc: string;
+};
+
+type OriginSignatureEntry = SignatureEntry & { 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 docsTarget = (library: Library): TsTypeTarget =>
+    recordTypeTarget(
+        library,
+        (name) => `${name.namespaceName}.${name.typeName}`,
+        () => "GObject.Type",
+    );
+
+const renderDocsType = (library: Library, ref: TypeId | undefined, isNullable: boolean): string => {
+    const base = renderBaseType(library, docsTarget(library), ref);
 
-export const renderDocsType = (library: Library, ref: TypeId | undefined, isNullable: boolean): string => {
-    const base = renderBaseTypeFor(library, docsTarget(library), ref);
     return isNullable ? `${base} | null` : base;
 };
 
-const renderDocsHandlerResultType = (library: Library, signal: GirSignal): string =>
+const renderDocsHandlerResultType = (library: Library, signal: GirCallable): string =>
     renderHandlerResultType({
         library,
         signal,
@@ -42,106 +49,127 @@ const renderDocsHandlerResultType = (library: Library, signal: GirSignal): strin
         optOut: true,
     });
 
-const renderDocsHandlerParameters = (library: Library, signal: GirSignal): string[] =>
+const renderDocsHandlerParameters = (library: Library, signal: GirCallable): string[] =>
     renderHandlerParameters(signal.parameters, (ref, nullable) => renderDocsType(library, ref, nullable));
 
-export const renderDocsSignalSignature = (library: Library, signal: GirSignal, selfType: string): string => {
+const renderDocsSignalSignature = (library: Library, signal: GirCallable, selfType: string): string => {
     const params = [...renderDocsHandlerParameters(library, signal), `self: ${selfType}`];
+
     return `(${params.join(", ")}) => ${renderDocsHandlerResultType(library, signal)}`;
 };
 
-export const renderDocsSignalHandlerType = (library: Library, signal: GirSignal): string =>
+const renderDocsSignalHandlerType = (library: Library, signal: GirCallable): string =>
     `(${renderDocsHandlerParameters(library, signal).join(", ")}) => ${renderDocsHandlerResultType(library, signal)}`;
 
-const DOCS_DEFAULT_VALUES: Record<string, string> = { TRUE: "true", FALSE: "false", NULL: "null" };
-
-export const docsDefaultValue = (value: string): string => DOCS_DEFAULT_VALUES[value] ?? value;
+const docsDefaultValue = (value: string): string => DOCS_DEFAULT_VALUES[value] ?? value;
 
 const stripDocMedia = (markdown: string): string =>
     markdown
-        .replace(/<picture[\s\S]*?<\/picture>/g, "")
-        .replace(/<video[\s\S]*?(?:<\/video>|\/>)/g, "")
-        .replace(/<img[^>]*>/g, "");
+        .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 } => {
+    if (FENCE_LINE.test(line)) {
+        return { text: line, inFence: !isInFence };
+    }
+
+    if (isInFence) {
+        return { text: line, inFence: isInFence };
+    }
+
+    return { text: HEADING_LINE.test(line) ? `#${line}` : line, inFence: isInFence };
+};
 
 const demoteHeadings = (markdown: string): string => {
-    let inFence = false;
-    return markdown
-        .split("\n")
-        .map((line) => {
-            if (/^\s*(```|~~~)/.test(line)) {
-                inFence = !inFence;
-                return line;
-            }
-            if (inFence) return line;
-            return /^#{1,5}\s/.test(line) ? `#${line}` : line;
-        })
-        .join("\n");
+    let isInFence = false;
+    const lines: string[] = [];
+
+    for (const line of markdown.split("\n")) {
+        const result = demoteLine(line, isInFence);
+        isInFence = result.inFence;
+        lines.push(result.text);
+    }
+
+    return lines.join("\n");
 };
 
-export const docMarkdown = (doc: string | undefined): string =>
+const docMarkdown = (doc: string | undefined): string =>
     doc === undefined || doc.length === 0 ? "" : demoteHeadings(stripDocMedia(gtkDocToMarkdown(doc))).trim();
 
 const stripMarkdown = (markdown: string): string =>
     markdown
-        .replace(/```[\s\S]*?```/g, " ")
-        .replace(/`([^`]*)`/g, "$1")
-        .replace(/\[([^\]]*)\]\([^)]*\)/g, "$1")
-        .replace(/[*_#>]/g, "")
-        .replace(/\s+/g, " ")
+        .replaceAll(/```[\s\S]*?```/g, " ")
+        .replaceAll(/`([^`]*)`/g, "$1")
+        .replaceAll(/\[([^[\]]*)\]\([^)]*\)/g, "$1")
+        .replaceAll(/[*_#>]/g, "")
+        .replaceAll(/\s+/g, " ")
         .trim();
 
-export const firstSentence = (doc: string | undefined): string => {
+const firstSentence = (doc: string | undefined): string => {
     const text = stripMarkdown(docMarkdown(doc));
-    if (text.length === 0) return "";
-    const match = text.match(/^.*?[.!?](?=\s|$)/);
+
+    if (text.length === 0) {
+        return "";
+    }
+
+    const match = /^.*?[.!?](?=\s|$)/.exec(text);
     const sentence = match?.[0] ?? text;
+
     return sentence.length > 220 ? `${sentence.slice(0, 217)}...` : sentence;
 };
 
-export const elementSlug = (className: string): string =>
+const elementSlug = (className: string): string =>
     className
-        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
-        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2")
+        .replaceAll(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .replaceAll(/([A-Z])(?=[A-Z][a-z])/g, "$1-")
         .toLowerCase();
 
-export const joinSections = (sections: string[]): string =>
+const implementsLine = (names: string[]): string[] => {
+    if (names.length === 0) {
+        return [];
+    }
+
+    const quotedNames = names.map((name) => `\`${name}\``).join(", ");
+
+    return [`Implements ${quotedNames}.`];
+};
+
+const joinSections = (sections: string[]): string =>
     `${sections.filter((section) => section.length > 0).join("\n\n")}\n`;
 
-export const metaBlock = (name: string, meta: string, doc: string): string => {
+const metaBlock = (name: string, meta: string, doc: string): string => {
     const lines = [`### \`${name}\``, "", meta];
-    if (doc.length > 0) lines.push("", doc);
+
+    if (doc.length > 0) {
+        lines.push("", doc);
+    }
+
     return lines.join("\n");
 };
 
-export const signatureBlock = (name: string, signature: string, notes: string[]): string => {
+const signatureBlock = (name: string, signature: string, notes: string[]): string => {
     const lines = [`### \`${name}\``, "", `\`\`\`ts\n${signature}\n\`\`\``];
+
     for (const note of notes) {
-        if (note.length > 0) lines.push("", note);
+        if (note.length > 0) {
+            lines.push("", note);
+        }
     }
+
     return lines.join("\n");
 };
 
-const LEADING_NAMESPACES = ["Gtk", "Adw"];
-
-export const namespaceOrder = (name: string): string => {
+const namespaceOrder = (name: string): string => {
     const index = LEADING_NAMESPACES.indexOf(name);
-    return index === -1 ? `1${name}` : `0${index}`;
-};
-
-const DOCS_SIGNATURE_NAMESPACE = "$docs";
-
-export const docsSignatureContext = (namespace: GirNamespace, library: Library): ModuleContext =>
-    new ModuleContext({ ...namespace, name: DOCS_SIGNATURE_NAMESPACE }, library);
 
-export type SignatureEntry = {
-    name: string;
-    signature: string;
-    doc: string;
+    return index === -1 ? `1${name}` : `0${String(index)}`;
 };
 
-export type OriginSignatureEntry = SignatureEntry & { origin: string | undefined };
+const docsSignatureContext = (namespace: GirNamespace, library: Library): ModuleContext =>
+    new ModuleContext({ ...namespace, name: DOCS_SIGNATURE_NAMESPACE }, library);
 
-export const originSignatureBlocks = (entries: OriginSignatureEntry[]): string[] =>
+const originSignatureBlocks = (entries: OriginSignatureEntry[]): string[] =>
     sortStringsBy(entries, (item) => item.name).map((item) =>
         signatureBlock(item.name, item.signature, [
             item.origin === undefined ? "" : `From \`${item.origin}\`.`,
@@ -149,43 +177,79 @@ export const originSignatureBlocks = (entries: OriginSignatureEntry[]): string[]
         ]),
     );
 
-export const classMethodEntries = (library: Library, namespace: GirNamespace, klass: GirClass): SignatureEntry[] => {
+const classMethodEntries = (library: Library, namespace: GirNamespace, klass: GirClass): SignatureEntry[] => {
     const realContext = new ModuleContext(namespace, library);
     const signatureContext = docsSignatureContext(namespace, library);
-    const className = toPascalCase(klass.name);
+    const className = pascalCase(klass.name);
     const inherited = collectInheritedMethods(realContext, klass);
-    return instanceMethodEntries(signatureContext, klass.methods, (method) =>
+
+    return instanceMethodEntries(signatureContext, klass, (method) =>
         conflictRename(realContext, method, inherited, className),
     );
 };
 
-export const methodsSectionBlocks = (entries: SignatureEntry[], intro: string): string[] =>
+const methodsSectionBlocks = (entries: SignatureEntry[], intro: string): string[] =>
     entries.length === 0
         ? []
         : ["## Methods", intro, ...entries.map((item) => signatureBlock(item.name, item.signature, [item.doc]))];
 
-export const instanceMethodEntries = (
+const instanceMethodEntries = (
     signatureContext: ModuleContext,
-    methods: GirFunction[],
+    klass: GirClass,
     rename: (fn: GirFunction) => string | undefined,
 ): SignatureEntry[] => {
-    const deduped = dedupeCallables(methods);
-    const siblings = indexMethodsByName(deduped);
+    const deduped = dedupeCallables(klass.methods);
+
+    const scope = instanceScope(pascalCase(klass.name), {
+        constructors: dedupeCallables(klass.constructors),
+        functions: dedupeCallables(klass.functions),
+        methods: deduped,
+    });
+
     const entries: SignatureEntry[] = [];
+
     for (const method of deduped) {
         const nameOverride = rename(method);
+
         const rendered = renderInstanceMethodSignature(
             signatureContext,
             { ...method, doc: undefined },
-            siblings,
+            scope,
             nameOverride,
         );
-        if (rendered === undefined) continue;
+
+        if (rendered === undefined) {
+            continue;
+        }
+
         entries.push({
             name: nameOverride ?? methodExportName(method),
             signature: rendered.trim().replace(/;$/, ""),
             doc: docMarkdown(method.doc),
         });
     }
+
     return sortStringsBy(entries, (entry) => entry.name);
 };
+
+export {
+    renderDocsType,
+    renderDocsSignalSignature,
+    renderDocsSignalHandlerType,
+    docsDefaultValue,
+    docMarkdown,
+    firstSentence,
+    elementSlug,
+    implementsLine,
+    joinSections,
+    metaBlock,
+    signatureBlock,
+    namespaceOrder,
+    docsSignatureContext,
+    originSignatureBlocks,
+    classMethodEntries,
+    methodsSectionBlocks,
+    instanceMethodEntries,
+    type SignatureEntry,
+    type OriginSignatureEntry,
+};