starlight-fsharp-oracle 0.1.0

package/dist/Generate.js

@@ -0,0 +1,254 @@
+
+import { join, concat, split, substring, replace } from "./fable_modules/fable-library-js.5.0.0-rc.7/String.js";
+import { cons, append, toArray, exists, isEmpty, map, filter, ofArray, collect, sort } from "./fable_modules/fable-library-js.5.0.0-rc.7/List.js";
+import { List_distinct } from "./fable_modules/fable-library-js.5.0.0-rc.7/Seq2.js";
+import { scan, tail } from "./fable_modules/fable-library-js.5.0.0-rc.7/Array.js";
+import { curry2, comparePrimitives, stringHash } from "./fable_modules/fable-library-js.5.0.0-rc.7/Util.js";
+import { renderRootIndexPage, renderEntityPage, renderModulePage, renderNamespacePage } from "./Render.js";
+import { singleton, append as append_1, map as map_1, collect as collect_1, delay, toList } from "./fable_modules/fable-library-js.5.0.0-rc.7/Seq.js";
+import { Entity__get_Name, Entity__get_FullName } from "./FSharp.Oracle.Schema/Schema.js";
+
+function toSlug(name) {
+    const sanitized = replace(name.toLowerCase(), ".", "-");
+    const backtickIdx = sanitized.lastIndexOf("`") | 0;
+    if (backtickIdx >= 0) {
+        return substring(sanitized, 0, backtickIdx);
+    }
+    else {
+        return sanitized;
+    }
+}
+
+function expandNamespaces(namespaces) {
+    return sort(List_distinct(collect((ns) => {
+        const parts = split(ns, ["."], undefined, 0);
+        return ofArray(tail(scan((acc, part) => {
+            if (acc === "") {
+                return part;
+            }
+            else {
+                return concat(acc, ".", ...part);
+            }
+        }, "", parts)));
+    }, namespaces), {
+        Equals: (x, y) => (x === y),
+        GetHashCode: (x) => (stringHash(x) | 0),
+    }), {
+        Compare: (x_1, y_1) => (comparePrimitives(x_1, y_1) | 0),
+    });
+}
+
+function namespacesOf(modules) {
+    return expandNamespaces(List_distinct(filter((ns) => (ns !== ""), map((m_1) => m_1.Namespace, filter((m) => !m.IsSynthetic, modules))), {
+        Equals: (x, y) => (x === y),
+        GetHashCode: (x) => (stringHash(x) | 0),
+    }));
+}
+
+function escapeYaml(s) {
+    return replace(replace(replace(replace(s, "\\", "\\\\"), "\"", "\\\""), "\n", "\\n"), "\r", "");
+}
+
+function toMdxPage(page) {
+    let headingsSection;
+    if (isEmpty(page.TocEntries)) {
+        headingsSection = "headings: []";
+    }
+    else {
+        const entries = join("\n", map((e) => (`  - depth: ${e.Depth}
+    slug: "${escapeYaml(e.Slug)}"
+    text: "${escapeYaml(e.Text)}"`), page.TocEntries));
+        headingsSection = ("headings:\n" + entries);
+    }
+    return `---
+layout: 'starlight-fsharp-oracle/layouts/FSharpDocLayout.astro'
+title: "${escapeYaml(page.Title)}"
+${headingsSection}
+---
+
+import DocEntry from 'starlight-fsharp-oracle/components/DocEntry.astro';
+import { Aside } from '@astrojs/starlight/components';
+
+${page.TemplateBody}`;
+}
+
+export function namespacePages(outputBase, modules) {
+    const realModules = filter((m) => !m.IsSynthetic, modules);
+    const allNamespaces = namespacesOf(modules);
+    const htmlLinkGen = (name, fullName) => (`<a href="/${outputBase}/${toSlug(fullName)}">${name}</a>`);
+    const directChildNamespaces = (ns) => filter((other) => {
+        if (other.startsWith(ns + ".") && !(other.slice(ns.length + 1, other.length).indexOf(".") >= 0)) {
+            return !exists((m_1) => (m_1.FullName === other), realModules);
+        }
+        else {
+            return false;
+        }
+    }, allNamespaces);
+    const syntheticModules = filter((m_2) => m_2.IsSynthetic, modules);
+    return map((ns_1) => {
+        const slug = toSlug(ns_1);
+        const modulesInNs = filter((m_3) => (m_3.Namespace === ns_1), realModules);
+        const subNamespaces = directChildNamespaces(ns_1);
+        const entitiesInNs = collect((m_5) => m_5.Entities, filter((m_4) => (m_4.Namespace === ns_1), syntheticModules));
+        return [slug, toMdxPage(renderNamespacePage(curry2(htmlLinkGen))(ns_1)(subNamespaces)(entitiesInNs)(modulesInNs))];
+    }, allNamespaces);
+}
+
+export function modulePages(outputBase, modules) {
+    const realModules = filter((m) => !m.IsSynthetic, modules);
+    const htmlLinkGen = (name, fullName) => (`<a href="/${outputBase}/${toSlug(fullName)}">${name}</a>`);
+    return map((m_1) => {
+        const subModules = filter((other) => (other.Namespace === m_1.FullName), realModules);
+        return [toSlug(m_1.FullName), toMdxPage(renderModulePage(curry2(htmlLinkGen))(m_1)(subModules))];
+    }, realModules);
+}
+
+export function entityPages(outputBase, modules) {
+    const htmlLinkGen = (name, fullName) => (`<a href="/${outputBase}/${toSlug(fullName)}">${name}</a>`);
+    return toList(delay(() => collect_1((m) => map_1((e) => [toSlug(Entity__get_FullName(e)), toMdxPage(renderEntityPage(curry2(htmlLinkGen))(e)(m))], m.Entities), modules)));
+}
+
+export function rootIndexPage(outputBase, assemblies, modules) {
+    const htmlLinkGen = (name, fullName) => (`<a href="/${outputBase}/${toSlug(fullName)}">${name}</a>`);
+    const globalModules = filter((m) => {
+        if (!m.IsSynthetic) {
+            return m.Namespace === "";
+        }
+        else {
+            return false;
+        }
+    }, modules);
+    return ["index", toMdxPage(renderRootIndexPage(curry2(htmlLinkGen))(assemblies)(globalModules))];
+}
+
+function sidebarLink(outputBase, label, fullName, letter, kind) {
+    return {
+        label: label,
+        link: concat("/", outputBase, "/", ...toSlug(fullName)),
+    };
+}
+
+function sidebarGroup(label, letter, kind, items) {
+    return {
+        label: label,
+        items: toArray(items),
+        collapsed: true,
+    };
+}
+
+function entityLetterAndKind(entity) {
+    switch (entity.tag) {
+        case 1:
+            return ["U", "union"];
+        case 3:
+            return ["C", "class"];
+        case 4:
+            return ["I", "interface"];
+        case 2:
+            return ["A", "abbrev"];
+        case 5:
+            return ["E", "enum"];
+        case 6:
+            return ["M", "measure"];
+        case 7:
+            return ["X", "exception"];
+        case 8:
+            return ["D", "delegate"];
+        default:
+            return ["R", "record"];
+    }
+}
+
+function entitySidebarItem(outputBase, entity) {
+    const patternInput = entityLetterAndKind(entity);
+    const letter = patternInput[0];
+    const kind = patternInput[1];
+    return {
+        label: Entity__get_Name(entity),
+        link: concat("/", outputBase, "/", ...toSlug(Entity__get_FullName(entity))),
+    };
+}
+
+/**
+ * Returns a Starlight sidebar group with a full hierarchy:
+ * namespaces → modules → entities.
+ */
+export function sidebarTree(outputBase, label, modules) {
+    const realModules = filter((m) => !m.IsSynthetic, modules);
+    const syntheticModules = filter((m_1) => m_1.IsSynthetic, modules);
+    const allNamespaces = namespacesOf(modules);
+    const moduleHref = (m_2) => concat("/", outputBase, "/", ...toSlug(m_2.FullName));
+    const anchorLink = (label_1, href) => ({
+        label: label_1,
+        link: href,
+    });
+    const moduleSidebarItem = (m_3) => {
+        const subModules = filter((other) => (other.Namespace === m_3.FullName), realModules);
+        const overviewLink = {
+            label: "Overview",
+            link: moduleHref(m_3),
+        };
+        const entityItems = map((entity) => entitySidebarItem(outputBase, entity), m_3.Entities);
+        const functionItems = map((f) => anchorLink(f.Name, concat(moduleHref(m_3), "#", ...f.Name)), m_3.Functions);
+        const valueItems = map((v) => anchorLink(v.Name, concat(moduleHref(m_3), "#", ...v.Name)), m_3.Values);
+        const subModuleItems = map(moduleSidebarItem, subModules);
+        const children = append(cons(overviewLink, entityItems), append(functionItems, append(valueItems, subModuleItems)));
+        return sidebarGroup(m_3.Name, "M", "module", children);
+    };
+    const buildNsGroup = (ns) => {
+        let shortName;
+        const lastDot = ns.lastIndexOf(".") | 0;
+        shortName = ((lastDot < 0) ? ns : ns.slice(lastDot + 1, ns.length));
+        const directChildNs = filter((other_1) => {
+            if (other_1.startsWith(ns + ".") && !(other_1.slice(ns.length + 1, other_1.length).indexOf(".") >= 0)) {
+                return !exists((m_4) => (m_4.FullName === other_1), realModules);
+            }
+            else {
+                return false;
+            }
+        }, allNamespaces);
+        const modulesInNs = filter((m_5) => (m_5.Namespace === ns), realModules);
+        const syntheticInNs = filter((m_6) => (m_6.Namespace === ns), syntheticModules);
+        const items = toList(delay(() => append_1(map(moduleSidebarItem, modulesInNs), delay(() => append_1(collect_1((sm) => {
+            if (sm.Name === "global") {
+                return map((entity_1) => entitySidebarItem(outputBase, entity_1), sm.Entities);
+            }
+            else {
+                let smShortName;
+                const lastDot_1 = sm.FullName.lastIndexOf(".") | 0;
+                smShortName = ((lastDot_1 < 0) ? sm.FullName : sm.FullName.slice(lastDot_1 + 1, sm.FullName.length));
+                return singleton(sidebarGroup(smShortName, "N", "namespace", map((entity_2) => entitySidebarItem(outputBase, entity_2), sm.Entities)));
+            }
+        }, syntheticInNs), delay(() => map(buildNsGroup, directChildNs)))))));
+        return sidebarGroup(shortName, "N", "namespace", items);
+    };
+    const topLevelNs = filter((ns_1) => {
+        if (!exists((other_2) => ns_1.startsWith(other_2 + "."), allNamespaces)) {
+            return !exists((m_7) => (m_7.FullName === ns_1), realModules);
+        }
+        else {
+            return false;
+        }
+    }, allNamespaces);
+    const globalModules = filter((m_8) => (m_8.Namespace === ""), realModules);
+    const overviewLink_1 = {
+        label: "Overview",
+        link: concat("/", ...outputBase),
+    };
+    const items_1 = toList(delay(() => append_1(singleton(overviewLink_1), delay(() => append_1(map(moduleSidebarItem, globalModules), delay(() => map(buildNsGroup, topLevelNs)))))));
+    return {
+        label: label,
+        items: toArray(items_1),
+    };
+}
+
+/**
+ * Returns a tiny inline script that publishes the sidebar label so that
+ * the external sidebar-controls.js file can find the right section without
+ * needing any F#-generated JS logic.
+ */
+export function sidebarLabelInitScript(sidebarLabel) {
+    const escaped = replace(replace(sidebarLabel, "\\", "\\\\"), "\'", "\\\'");
+    return concat("window.__fsharpSidebarLabel = \'", escaped, ..."\';");
+}
+

package/dist/Helpers.js

@@ -0,0 +1,69 @@
+
+import { Union } from "./fable_modules/fable-library-js.5.0.0-rc.7/Types.js";
+import { union_type, string_type } from "./fable_modules/fable-library-js.5.0.0-rc.7/Reflection.js";
+import { concat } from "./fable_modules/fable-library-js.5.0.0-rc.7/String.js";
+import * as fs from "fs";
+import { some } from "./fable_modules/fable-library-js.5.0.0-rc.7/Option.js";
+import { choose } from "./fable_modules/fable-library-js.5.0.0-rc.7/List.js";
+
+/**
+ * Result type for file operations
+ */
+export class FileOperationResult$1 extends Union {
+    constructor(tag, fields) {
+        super();
+        this.tag = tag;
+        this.fields = fields;
+    }
+    cases() {
+        return ["Ok", "Error"];
+    }
+}
+
+export function FileOperationResult$1_$reflection(gen0) {
+    return union_type("Starlight.FSharp.Helpers.FileOperationResult`1", [gen0], FileOperationResult$1, () => [[["Item", gen0]], [["Item", string_type]]]);
+}
+
+/**
+ * Wraps fs.writeFileSync with error handling
+ */
+export function writeSync(path, content) {
+    try {
+        fs.writeFileSync(path, content, some("utf-8"));
+        return new FileOperationResult$1(0, [undefined]);
+    }
+    catch (ex) {
+        return new FileOperationResult$1(1, [concat("Failed to write file \'", path, "\': ", ...ex.message)]);
+    }
+}
+
+/**
+ * Wraps fs.mkdirSync with error handling
+ */
+export function mkdirSync(path) {
+    try {
+        fs.mkdirSync(path, {
+            recursive: true,
+        });
+        return new FileOperationResult$1(0, [undefined]);
+    }
+    catch (ex) {
+        return new FileOperationResult$1(1, [concat("Failed to create directory \'", path, "\': ", ...ex.message)]);
+    }
+}
+
+/**
+ * Collects all errors from a list of results
+ */
+export function collectErrors(results) {
+    return choose((_arg) => {
+        if (_arg.tag === 0) {
+            return undefined;
+        }
+        else {
+            const msg = _arg.fields[0];
+            return msg;
+        }
+    }, results);
+}
+

package/dist/Plugin.js

@@ -0,0 +1,139 @@
+
+import * as path from "path";
+import { fileURLToPath } from "node:url";
+import { toArray, singleton, append, delay, toList } from "./fable_modules/fable-library-js.5.0.0-rc.7/Seq.js";
+import * as child_process from "child_process";
+import { map, defaultArg, some } from "./fable_modules/fable-library-js.5.0.0-rc.7/Option.js";
+import { stringHash, Exception } from "./fable_modules/fable-library-js.5.0.0-rc.7/Util.js";
+import { join, concat, interpolate } from "./fable_modules/fable-library-js.5.0.0-rc.7/String.js";
+import { Extra_empty } from "./fable_modules/Thoth.Json.Core.Auto.0.1.0/Domain.fs.js";
+import { Root_$reflection } from "./FSharp.Oracle.Schema/Schema.js";
+import { generateDecoder } from "./fable_modules/Thoth.Json.Core.Auto.0.1.0/Decode.fs.js";
+import { unsafeFromString } from "./fable_modules/Thoth.Json.JavaScript.0.5.0/Decode.fs.js";
+import { PromiseBuilder__Delay_62FBFDE1, PromiseBuilder__Run_212F1D4B } from "./fable_modules/Fable.Promise.3.2.0/Promise.fs.js";
+import { promise } from "./fable_modules/Fable.Promise.3.2.0/PromiseImpl.fs.js";
+import { createRenderer } from "astro-expressive-code";
+import { generateCss } from "./Themes.js";
+import { length, isEmpty, contains, filter, map as map_1, collect } from "./fable_modules/fable-library-js.5.0.0-rc.7/List.js";
+import { entityPages, rootIndexPage, namespacePages as namespacePages_1, modulePages as modulePages_1, sidebarTree, sidebarLabelInitScript } from "./Generate.js";
+import { collectErrors, FileOperationResult$1, writeSync, mkdirSync } from "./Helpers.js";
+
+function runExtractor(logger, outputBase, dllPaths) {
+    const maxBuffer = ((50 * 1024) * 1024) | 0;
+    const oracleProject = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "packages", "FSharp.Oracle");
+    const args = toList(delay(() => append(singleton("run"), delay(() => append(singleton("--project"), delay(() => append(singleton(oracleProject), delay(() => append(singleton("--"), delay(() => append(singleton("--output-base"), delay(() => append(singleton(outputBase), delay(() => dllPaths))))))))))))));
+    const result = child_process.spawnSync("dotnet", Array.from(args), some({
+        encoding: "utf-8",
+        maxBuffer: maxBuffer,
+    }));
+    if (result.error) {
+        throw result.error;
+    }
+    else if (result.status !== 0) {
+        throw new Exception(`F# docs extractor failed (exit ${result.status}):
+${interpolate("%A%P()", [result.stderr])}`);
+    }
+    else {
+        const json = result.stdout;
+        let decoder_1;
+        const extra_1 = Extra_empty;
+        const losslessOption_1 = true;
+        const ty = Root_$reflection();
+        const decoder = generateDecoder(undefined, extra_1.DecoderOverrides, false, losslessOption_1, ty);
+        decoder_1 = decoder;
+        return unsafeFromString(decoder_1, json);
+    }
+}
+
+function starlightFSharpDoc(pluginOptions) {
+    return {
+        hooks: {
+            "config:setup": (hookOptions) => PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => {
+                const logger = hookOptions.logger;
+                const astroConfig = hookOptions.astroConfig;
+                const command = hookOptions.command;
+                switch (command) {
+                    case "dev":
+                    case "build":
+                    case "sync": {
+                        logger.info("Extracting F# API docs...");
+                        let updateConfig;
+                        const clo = hookOptions.updateConfig;
+                        updateConfig = ((arg) => {
+                            clo(arg);
+                        });
+                        return createRenderer({}).then((_arg) => {
+                            let matchValue, matchValue_1, msg_1, msg;
+                            const ecRenderer = _arg;
+                            const themesCss = generateCss(ecRenderer);
+                            const outputBase = defaultArg(pluginOptions.output, "api");
+                            const root = runExtractor(logger, outputBase, toList(pluginOptions.assemblies));
+                            const modules = collect((_arg_1) => _arg_1.Modules, root.Assemblies);
+                            const sidebarLabel = defaultArg(map((s) => s.label, pluginOptions.sidebar), "API Reference");
+                            const existingSidebar = defaultArg(hookOptions.config.sidebar, []);
+                            updateConfig({
+                                head: [{
+                                    content: themesCss,
+                                    tag: "style",
+                                }, {
+                                    content: sidebarLabelInitScript(sidebarLabel),
+                                    tag: "script",
+                                }],
+                                sidebar: toArray(delay(() => append(existingSidebar, delay(() => singleton(sidebarTree(outputBase, sidebarLabel, modules)))))),
+                            });
+                            const outputDir = path.join(astroConfig.root.pathname, "src", "pages", outputBase);
+                            return ((matchValue = mkdirSync(outputDir), (matchValue.tag === 0) ? ((matchValue_1 = writeSync(path.join(outputDir, ".gitignore"), "# Autogenerated by starlight-fsharp-oracle\n**/*\n"), (matchValue_1.tag === 0) ? (Promise.resolve()) : ((msg_1 = matchValue_1.fields[0], (logger.warn(concat("Failed to write .gitignore: ", ...msg_1)), Promise.resolve()))))) : ((msg = matchValue.fields[0], (logger.error(msg), ((() => {
+                                throw new Exception(msg);
+                            })(), Promise.resolve())))))).then(() => PromiseBuilder__Delay_62FBFDE1(promise, () => {
+                                const modulePages = modulePages_1(outputBase, modules);
+                                const namespacePages = namespacePages_1(outputBase, modules);
+                                const moduleSlugs = map_1((tuple) => tuple[0], modulePages);
+                                const dedupedNamespacePages = filter((tupledArg) => {
+                                    const slug = tupledArg[0];
+                                    return !contains(slug, moduleSlugs, {
+                                        Equals: (x, y) => (x === y),
+                                        GetHashCode: (x) => (stringHash(x) | 0),
+                                    });
+                                }, namespacePages);
+                                const pages = toList(delay(() => append(singleton(rootIndexPage(outputBase, root.Assemblies, modules)), delay(() => append(dedupedNamespacePages, delay(() => append(modulePages, delay(() => entityPages(outputBase, modules)))))))));
+                                const writeResults = map_1((tupledArg_1) => {
+                                    const slug_1 = tupledArg_1[0];
+                                    const content = tupledArg_1[1];
+                                    const filePath = path.join(outputDir, slug_1 + ".mdx");
+                                    const matchValue_2 = writeSync(filePath, content);
+                                    if (matchValue_2.tag === 0) {
+                                        logger.info(concat("  wrote ", ...filePath));
+                                        return new FileOperationResult$1(0, [undefined]);
+                                    }
+                                    else {
+                                        const msg_2 = matchValue_2.fields[0];
+                                        logger.error(msg_2);
+                                        return new FileOperationResult$1(1, [msg_2]);
+                                    }
+                                }, pages);
+                                const errors = collectErrors(writeResults);
+                                if (!isEmpty(errors)) {
+                                    const errorMsg = (`Failed to write ${length(errors)} file(s):
+`) + join("\n", errors);
+                                    logger.error(errorMsg);
+                                    throw new Exception(errorMsg);
+                                    return Promise.resolve();
+                                }
+                                else {
+                                    return Promise.resolve();
+                                }
+                            }));
+                        });
+                    }
+                    default: {
+                        return Promise.resolve();
+                    }
+                }
+            })),
+        },
+        name: "starlight-fsharp-oracle",
+    };
+}
+
+export default (starlightFSharpDoc);
+

package/dist/Render/Documentation.js

@@ -0,0 +1,87 @@
+
+import { System_Text_StringBuilder__StringBuilder_NewLine, System_Text_StringBuilder__StringBuilder_WriteLine_Z721C83C5 } from "../Extensions/StringBuilder.js";
+import { h2, renderExamples, escapeMdxText } from "./Primitives.js";
+import { iterate } from "../fable_modules/fable-library-js.5.0.0-rc.7/Seq.js";
+import { toArray } from "../fable_modules/fable-library-js.5.0.0-rc.7/Option.js";
+import { ofArray, tryFind, collect, isEmpty } from "../fable_modules/fable-library-js.5.0.0-rc.7/List.js";
+import { disposeSafe, getEnumerator } from "../fable_modules/fable-library-js.5.0.0-rc.7/Util.js";
+import { FSharp_Oracle_Schema_TextNode__TextNode_ToHtml_Static_Z3A0E64B3, FSharp_Oracle_Schema_TextNode__TextNode_get_Html } from "../Extensions/TextNode.js";
+import { TextNode } from "../FSharp.Oracle.Schema/Schema.js";
+
+export function renderSummary(sb, xmlDoc) {
+    const matchValue = xmlDoc.Summary;
+    if (matchValue == null) {
+    }
+    else {
+        const summary = matchValue;
+        System_Text_StringBuilder__StringBuilder_WriteLine_Z721C83C5(sb, escapeMdxText(summary));
+        System_Text_StringBuilder__StringBuilder_NewLine(sb);
+    }
+}
+
+/**
+ * Renders summary + optional extra content + examples.
+ * Used by all DocEntry documentation closures for consistency.
+ */
+export function renderDocumentationBlock(sb, xmlDoc, renderExtra) {
+    renderSummary(sb, xmlDoc);
+    renderExtra();
+    renderExamples(sb, xmlDoc.Examples);
+}
+
+export function renderXmlDocSummaryAndRemarks(sb, toc, xmlDoc) {
+    iterate((summary) => {
+        h2(sb, toc, "description", "Description");
+        System_Text_StringBuilder__StringBuilder_WriteLine_Z721C83C5(sb, escapeMdxText(summary));
+        System_Text_StringBuilder__StringBuilder_NewLine(sb);
+    }, toArray(xmlDoc.Summary));
+    iterate((remarks) => {
+        System_Text_StringBuilder__StringBuilder_WriteLine_Z721C83C5(sb, escapeMdxText(remarks));
+        System_Text_StringBuilder__StringBuilder_NewLine(sb);
+    }, toArray(xmlDoc.Remarks));
+}
+
+function renderParamsAndReturns(sb, parameters, xmlDoc) {
+    if (!isEmpty(xmlDoc.Params)) {
+        System_Text_StringBuilder__StringBuilder_WriteLine_Z721C83C5(sb, "<strong>Parameters</strong>");
+        const enumerator = getEnumerator(collect((x) => x, parameters));
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                const parameter = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                const paramDoc = tryFind((p) => (p.Name === parameter.Name), xmlDoc.Params);
+                if (paramDoc == null) {
+                    System_Text_StringBuilder__StringBuilder_WriteLine_Z721C83C5(sb, FSharp_Oracle_Schema_TextNode__TextNode_get_Html(parameter.Declaration));
+                }
+                else {
+                    const paramDoc_1 = paramDoc;
+                    System_Text_StringBuilder__StringBuilder_WriteLine_Z721C83C5(sb, FSharp_Oracle_Schema_TextNode__TextNode_ToHtml_Static_Z3A0E64B3(ofArray([new TextNode(23, ["div", "fs-parameter__signature"]), new TextNode(20, []), parameter.Declaration, new TextNode(20, []), new TextNode(22, ["div"]), new TextNode(20, [])])));
+                    System_Text_StringBuilder__StringBuilder_WriteLine_Z721C83C5(sb, "<div class=\'fs-parameter__documentation\'>");
+                    System_Text_StringBuilder__StringBuilder_NewLine(sb);
+                    System_Text_StringBuilder__StringBuilder_WriteLine_Z721C83C5(sb, escapeMdxText(paramDoc_1.Doc));
+                    System_Text_StringBuilder__StringBuilder_NewLine(sb);
+                    System_Text_StringBuilder__StringBuilder_WriteLine_Z721C83C5(sb, "</div>");
+                }
+            }
+        }
+        finally {
+            disposeSafe(enumerator);
+        }
+    }
+    const matchValue = xmlDoc.Returns;
+    if (matchValue == null) {
+    }
+    else {
+        const returnDoc = matchValue;
+        System_Text_StringBuilder__StringBuilder_WriteLine_Z721C83C5(sb, "<strong>Returns</strong>");
+        System_Text_StringBuilder__StringBuilder_NewLine(sb);
+        System_Text_StringBuilder__StringBuilder_WriteLine_Z721C83C5(sb, escapeMdxText(returnDoc));
+        System_Text_StringBuilder__StringBuilder_NewLine(sb);
+    }
+}
+
+export function renderXmlDocBody(sb, parameters, xmlDoc) {
+    renderDocumentationBlock(sb, xmlDoc, () => {
+        renderParamsAndReturns(sb, parameters, xmlDoc);
+    });
+}
+