ardo 3.1.0 → 3.2.0

package/dist/generator-DcUomVnD.js

@@ -0,0 +1,1193 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import { readPackageUp } from "read-package-up";
+import { Application, ReflectionKind, TSConfigReader, TypeDocReader } from "typedoc";
+//#region src/typedoc/generator-config.ts
+function resolveTypeDocConfig(config) {
+	const sidebar = resolveSidebarConfig(config.sidebar);
+	const markdown = resolveMarkdownConfig(config.markdown);
+	return {
+		...config,
+		excludeExternals: withDefault(config.excludeExternals, true),
+		excludeInternal: withDefault(config.excludeInternal, true),
+		excludePrivate: withDefault(config.excludePrivate, true),
+		excludeProtected: withDefault(config.excludeProtected, false),
+		markdown,
+		out: withDefault(config.out, "api"),
+		sidebar,
+		sort: withDefault(config.sort, ["source-order"])
+	};
+}
+function getTypedocOptions(config) {
+	const options = {
+		entryPoints: config.entryPoints,
+		excludeExternals: config.excludeExternals,
+		excludeInternal: config.excludeInternal,
+		excludePrivate: config.excludePrivate,
+		excludeProtected: config.excludeProtected,
+		sort: config.sort,
+		tsconfig: config.tsconfig
+	};
+	applyOptionalOption(options, "exclude", config.exclude);
+	applyOptionalOption(options, "categoryOrder", config.categoryOrder);
+	applyOptionalOption(options, "groupOrder", config.groupOrder);
+	applyOptionalOption(options, "plugin", config.plugin);
+	applyOptionalOption(options, "readme", config.readme);
+	return options;
+}
+function applyOptionalOption(options, key, value) {
+	if (value != null) options[key] = value;
+}
+function withDefault(value, fallback) {
+	return value ?? fallback;
+}
+function resolveSidebarConfig(sidebar) {
+	return {
+		collapsed: withDefault(sidebar?.collapsed, false),
+		position: withDefault(sidebar?.position, 100),
+		title: withDefault(sidebar?.title, "API Reference")
+	};
+}
+function resolveMarkdownConfig(markdown) {
+	return {
+		breadcrumbs: withDefault(markdown?.breadcrumbs, true),
+		codeBlocks: withDefault(markdown?.codeBlocks, true),
+		hierarchy: withDefault(markdown?.hierarchy, true),
+		sourceBaseUrl: markdown?.sourceBaseUrl,
+		sourceLinks: withDefault(markdown?.sourceLinks, true)
+	};
+}
+//#endregion
+//#region src/typedoc/generator-shared.ts
+function groupProjectChildren(project, isComponentName) {
+	const grouped = {
+		componentItems: [],
+		functionsByFile: /* @__PURE__ */ new Map(),
+		standaloneItems: [],
+		typesByFile: /* @__PURE__ */ new Map()
+	};
+	const children = project.children ?? [];
+	for (const child of children) {
+		if (appendFunctionReflection(grouped, child, isComponentName)) continue;
+		if (appendTypeAliasReflection(grouped, child)) continue;
+		grouped.standaloneItems.push(child);
+	}
+	return grouped;
+}
+function appendFunctionReflection(grouped, child, isComponentName) {
+	const sourceFile = child.sources?.[0]?.fileName;
+	if (child.kind !== ReflectionKind.Function || sourceFile == null) return false;
+	if (isComponentName(child.name)) {
+		grouped.componentItems.push(child);
+		return true;
+	}
+	appendToMapList(grouped.functionsByFile, sourceFile, child);
+	return true;
+}
+function appendTypeAliasReflection(grouped, child) {
+	const sourceFile = child.sources?.[0]?.fileName;
+	if (child.kind !== ReflectionKind.TypeAlias || sourceFile == null) return false;
+	appendToMapList(grouped.typesByFile, sourceFile, child);
+	return true;
+}
+function appendToMapList(map, key, item) {
+	const items = map.get(key) ?? [];
+	items.push(item);
+	map.set(key, items);
+}
+function sortReflectionsByName(items) {
+	return [...items].sort((left, right) => left.name.localeCompare(right.name));
+}
+function getModuleNameFromPath(filePath, packageNameCache) {
+	const parts = filePath.split("/");
+	const basename = (parts.pop() ?? filePath).replace(/\.(?:ts|tsx|js|jsx)$/u, "");
+	const parent = parts.pop();
+	if (parent != null && parent !== "src") return `${parent}/${basename}`;
+	if (basename === "index") {
+		for (const packageName of packageNameCache.values()) if (packageName != null && packageName.length > 0) return packageName;
+	}
+	return basename;
+}
+function renderComment(parts) {
+	return parts.map((part) => part.text).join("");
+}
+function renderCommentShort(parts) {
+	const text = renderComment(parts);
+	const firstSentence = text.split(/[!.?]\s/u)[0];
+	if (firstSentence.length < text.length) return `${firstSentence}.`;
+	return text;
+}
+function getSlug(name) {
+	return name.toLowerCase().replaceAll(/[^\da-z]+/gu, "-").replaceAll(/^-|-$/gu, "");
+}
+function buildLink(basePath, category, slug) {
+	if (slug === "index") return `${basePath}/${category}`;
+	return `${basePath}/${category}/${slug}`;
+}
+function getSourceUrl(sourceBaseUrl, fileName, line) {
+	if (sourceBaseUrl == null || sourceBaseUrl.length === 0) return null;
+	return `${sourceBaseUrl.replace(/\/$/u, "")}/${fileName}#L${line}`;
+}
+function getKindName(kind) {
+	return {
+		[ReflectionKind.Project]: "Project",
+		[ReflectionKind.Module]: "Module",
+		[ReflectionKind.Namespace]: "Namespace",
+		[ReflectionKind.Enum]: "Enum",
+		[ReflectionKind.EnumMember]: "Enum Member",
+		[ReflectionKind.Variable]: "Variable",
+		[ReflectionKind.Function]: "Function",
+		[ReflectionKind.Class]: "Class",
+		[ReflectionKind.Interface]: "Interface",
+		[ReflectionKind.Constructor]: "Constructor",
+		[ReflectionKind.Property]: "Property",
+		[ReflectionKind.Method]: "Method",
+		[ReflectionKind.TypeAlias]: "Type"
+	}[kind] ?? "Unknown";
+}
+function getGroupUrlPrefix(kind) {
+	return {
+		[ReflectionKind.Enum]: "enums",
+		[ReflectionKind.Variable]: "variables",
+		[ReflectionKind.Class]: "classes",
+		[ReflectionKind.Interface]: "interfaces",
+		[ReflectionKind.Namespace]: "namespaces",
+		[ReflectionKind.Module]: "modules"
+	}[kind] ?? "other";
+}
+function getKindGroupName(kind, name) {
+	if (kind === ReflectionKind.Function) {
+		if (name.startsWith("use")) return "React Hooks";
+		if (isReactComponent(name)) return "React Components";
+		return "Functions";
+	}
+	switch (kind) {
+		case ReflectionKind.Interface: return "Interfaces";
+		case ReflectionKind.TypeAlias: return "Types";
+		case ReflectionKind.Class: return "Classes";
+		case ReflectionKind.Variable: return "Variables";
+		case ReflectionKind.Enum: return "Enums";
+		default: return "Other";
+	}
+}
+function isReactComponent(name) {
+	const first = name.slice(0, 1);
+	if (first.length === 0 || first !== first.toUpperCase()) return false;
+	if (name.includes("_") || name.startsWith("use")) return false;
+	if (name.endsWith("Props") || name.endsWith("Options") || name.endsWith("Config")) return false;
+	return true;
+}
+function createBreadcrumbs(basePath, pagePath) {
+	const parts = pagePath.split("/");
+	const breadcrumbs = [`[API](${basePath})`];
+	let currentPath = "";
+	for (const part of parts.slice(0, -1)) {
+		currentPath = currentPath.length > 0 ? `${currentPath}/${part}` : part;
+		breadcrumbs.push(`[${part}](${basePath}/${currentPath})`);
+	}
+	const leaf = parts.at(-1);
+	if (leaf != null) breadcrumbs.push(leaf);
+	return breadcrumbs.join(" / ");
+}
+function createNavigationLine(params) {
+	const { basePath, kind, navigation } = params;
+	const prefix = getGroupUrlPrefix(kind);
+	const prevLink = navigation.prev == null ? "" : `[← ${navigation.prev.name}](${buildLink(basePath, prefix, getSlug(navigation.prev.name))})`;
+	const nextLink = navigation.next == null ? "" : `[${navigation.next.name} →](${buildLink(basePath, prefix, getSlug(navigation.next.name))})`;
+	if (prevLink.length > 0 && nextLink.length > 0) return `${prevLink} | ${nextLink}`;
+	if (prevLink.length > 0) return prevLink;
+	if (nextLink.length > 0) return nextLink;
+	return null;
+}
+//#endregion
+//#region src/typedoc/generator-pages-categories.ts
+function generateCategoryIndexPages(context, grouped) {
+	const pages = [];
+	pushIfNotNull(pages, createComponentsIndexPage(context, grouped.componentItems));
+	pushIfNotNull(pages, createFunctionsIndexPage(context, grouped.functionsByFile));
+	pushIfNotNull(pages, createInterfacesIndexPage(context, grouped.standaloneItems));
+	pushIfNotNull(pages, createTypesIndexPage(context, grouped.typesByFile));
+	pushIfNotNull(pages, createClassesIndexPage(context, grouped.standaloneItems));
+	return pages;
+}
+function pushIfNotNull(docs, doc) {
+	if (doc != null) docs.push(doc);
+}
+function createComponentsIndexPage(context, components) {
+	if (components.length === 0) return null;
+	return {
+		content: renderSimpleItemIndex({
+			basePath: context.basePath,
+			category: "components",
+			items: components,
+			title: "Components"
+		}),
+		frontmatter: {
+			sidebar: false,
+			title: "Components"
+		},
+		path: "components/index.md"
+	};
+}
+function createInterfacesIndexPage(context, standaloneItems) {
+	const interfaces = standaloneItems.filter((item) => item.kind === ReflectionKind.Interface);
+	if (interfaces.length === 0) return null;
+	return {
+		content: renderSimpleItemIndex({
+			basePath: context.basePath,
+			category: "interfaces",
+			items: interfaces,
+			title: "Interfaces"
+		}),
+		frontmatter: {
+			sidebar: false,
+			title: "Interfaces"
+		},
+		path: "interfaces/index.md"
+	};
+}
+function createClassesIndexPage(context, standaloneItems) {
+	const classes = standaloneItems.filter((item) => item.kind === ReflectionKind.Class);
+	if (classes.length === 0) return null;
+	return {
+		content: renderSimpleItemIndex({
+			basePath: context.basePath,
+			category: "classes",
+			items: classes,
+			title: "Classes"
+		}),
+		frontmatter: {
+			sidebar: false,
+			title: "Classes"
+		},
+		path: "classes/index.md"
+	};
+}
+function renderSimpleItemIndex(params) {
+	const lines = [`# ${params.title}`, ""];
+	const sortedItems = sortReflectionsByName(params.items);
+	for (const item of sortedItems) {
+		const summary = item.comment?.summary;
+		const description = summary == null ? "" : ` - ${renderCommentShort(summary)}`;
+		const link = buildLink(params.basePath, params.category, getSlug(item.name));
+		lines.push(`- [${item.name}](${link})${description}`);
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+function createFunctionsIndexPage(context, functionsByFile) {
+	if (functionsByFile.size === 0) return null;
+	return {
+		content: renderModuleIndex({
+			basePath: context.basePath,
+			category: "functions",
+			modules: functionsByFile,
+			packageNameCache: context.packageNameCache,
+			title: "Functions"
+		}),
+		frontmatter: {
+			sidebar: false,
+			title: "Functions"
+		},
+		path: "functions/index.md"
+	};
+}
+function createTypesIndexPage(context, typesByFile) {
+	if (typesByFile.size === 0) return null;
+	return {
+		content: renderModuleIndex({
+			basePath: context.basePath,
+			category: "types",
+			modules: typesByFile,
+			packageNameCache: context.packageNameCache,
+			title: "Types"
+		}),
+		frontmatter: {
+			sidebar: false,
+			title: "Types"
+		},
+		path: "types/index.md"
+	};
+}
+function renderModuleIndex(params) {
+	const lines = [`# ${params.title}`, ""];
+	const sortedModules = [...params.modules.entries()].sort(([left], [right]) => {
+		const leftName = getModuleNameFromPath(left, params.packageNameCache);
+		const rightName = getModuleNameFromPath(right, params.packageNameCache);
+		return leftName.localeCompare(rightName);
+	});
+	for (const [sourceFile, items] of sortedModules) {
+		const moduleName = getModuleNameFromPath(sourceFile, params.packageNameCache);
+		const slug = getSlug(moduleName);
+		const itemNames = items.map((item) => item.name).sort().join(", ");
+		lines.push(`- [${moduleName}](${buildLink(params.basePath, params.category, slug)}) - ${itemNames}`);
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+//#endregion
+//#region src/typedoc/generator-render-component.ts
+function getTypeName(paramType) {
+	if (paramType == null || typeof paramType !== "object") return null;
+	const typeRecord = paramType;
+	if (typeof typeRecord.name === "string" && typeRecord.name.length > 0) return typeRecord.name;
+	if (typeRecord.type !== "reference") return null;
+	if (typeof typeRecord.qualifiedName === "string" && typeRecord.qualifiedName.length > 0) return typeRecord.qualifiedName;
+	return null;
+}
+function getPropsFromType(context, paramType) {
+	const inlineProps = getInlineDeclarationProps(paramType);
+	if (inlineProps.length > 0) return inlineProps;
+	const typeName = getTypeName(paramType);
+	if (typeName == null) return [];
+	const reflection = findReflectionByName(context, typeName);
+	if (reflection == null) return [];
+	return extractPropsFromChildren(reflection.children ?? []);
+}
+function getInlineDeclarationProps(paramType) {
+	if (paramType == null || typeof paramType !== "object") return [];
+	const declaration = paramType.declaration;
+	if (declaration == null) return [];
+	return extractPropsFromChildren(declaration.children ?? []);
+}
+function findReflectionByName(context, typeName) {
+	const direct = context.project.getChildByName(typeName);
+	if (direct != null && "children" in direct) return direct;
+	const children = context.project.children ?? [];
+	for (const child of children) if (child.name === typeName) return child;
+	return null;
+}
+function extractPropsFromChildren(children) {
+	return children.map((child) => ({
+		description: child.comment?.summary == null ? "" : renderCommentShort(child.comment.summary),
+		name: child.name,
+		optional: child.flags.isOptional,
+		type: child.type == null ? "unknown" : child.type.toString()
+	}));
+}
+function renderComponentSignature(context, signature, componentName) {
+	const lines = [];
+	const propsParam = signature.parameters?.[0];
+	const props = propsParam == null ? [] : getPropsFromType(context, propsParam.type);
+	const propsTypeName = propsParam == null ? null : getTypeName(propsParam.type);
+	appendComponentUsageBlock(lines, componentName, props);
+	appendComponentPropsTable({
+		context,
+		lines,
+		props,
+		propsTypeName
+	});
+	return lines.join("\n");
+}
+function appendComponentUsageBlock(lines, componentName, props) {
+	const hasChildren = props.some((prop) => prop.name === "children");
+	const displayProps = props.filter((prop) => prop.name !== "children");
+	lines.push("```tsx");
+	lines.push(`<${componentName}`);
+	if (displayProps.length > 0) for (const prop of displayProps) {
+		const optionalMark = prop.optional ? "?" : "";
+		lines.push(`  ${prop.name}${optionalMark}={${prop.type}}`);
+	}
+	else if (!hasChildren) lines.push("  {...props}");
+	if (hasChildren) {
+		lines.push(">");
+		lines.push("  {children}");
+		lines.push(`</${componentName}>`);
+	} else lines.push("/>");
+	lines.push("```");
+}
+function appendComponentPropsTable(params) {
+	const { context, lines, props, propsTypeName } = params;
+	if (props.length === 0) return;
+	lines.push("");
+	lines.push(getPropsHeading(context.basePath, propsTypeName));
+	lines.push("");
+	lines.push("| Prop | Type | Required | Description |");
+	lines.push("|------|------|----------|-------------|");
+	for (const prop of props) {
+		const required = prop.optional ? "No" : "Yes";
+		const description = prop.description.length > 0 ? prop.description : "-";
+		lines.push(`| ${prop.name} | \`${prop.type}\` | ${required} | ${description} |`);
+	}
+}
+function getPropsHeading(basePath, propsTypeName) {
+	if (propsTypeName == null) return "## Props";
+	return `## [Props](${buildLink(basePath, "interfaces", getSlug(propsTypeName))})`;
+}
+//#endregion
+//#region src/typedoc/generator-pages-components.ts
+function generateComponentPage(params) {
+	const { component, context, navigation } = params;
+	const slug = getSlug(component.name);
+	return {
+		content: createComponentContent(context, component, navigation),
+		frontmatter: {
+			description: component.comment?.summary == null ? `${component.name} component` : renderCommentShort(component.comment.summary),
+			title: component.name
+		},
+		path: `components/${slug}.md`
+	};
+}
+function createComponentContent(context, component, navigation) {
+	const lines = [`# ${component.name}`, ""];
+	const summary = component.comment?.summary;
+	if (summary != null) {
+		lines.push(renderComment(summary));
+		lines.push("");
+	}
+	appendComponentUsage(lines, context, component);
+	appendExamples$1(lines, component);
+	appendSourceLink$1(lines, context, component);
+	appendComponentNavigation({
+		component,
+		context,
+		lines,
+		navigation
+	});
+	return lines.join("\n");
+}
+function appendComponentUsage(lines, context, component) {
+	const signatures = component.signatures ?? [];
+	if (signatures.length === 0) return;
+	lines.push("## Usage");
+	lines.push("");
+	for (const signature of signatures) {
+		lines.push(renderComponentSignature(context, signature, component.name));
+		lines.push("");
+	}
+}
+function appendExamples$1(lines, reflection) {
+	const examples = (reflection.comment?.blockTags ?? []).filter((tag) => tag.tag === "@example");
+	if (examples.length === 0) return;
+	lines.push("## Example");
+	lines.push("");
+	for (const example of examples) {
+		lines.push(renderComment(example.content));
+		lines.push("");
+	}
+}
+function appendSourceLink$1(lines, context, reflection) {
+	if (!context.config.markdown.sourceLinks) return;
+	const source = reflection.sources?.[0];
+	if (source == null) return;
+	const sourceUrl = getSourceUrl(context.config.markdown.sourceBaseUrl, source.fileName, source.line);
+	if (sourceUrl == null) return;
+	lines.push(`[Source](${sourceUrl})`);
+	lines.push("");
+}
+function appendComponentNavigation(params) {
+	const { component, context, lines, navigation } = params;
+	const line = createNavigationLine({
+		basePath: context.basePath,
+		kind: component.kind,
+		navigation
+	});
+	if (line == null) return;
+	lines.push("---");
+	lines.push("");
+	lines.push(line);
+	lines.push("");
+}
+//#endregion
+//#region src/typedoc/generator-render.ts
+function renderSignature(context, signature) {
+	const lines = [];
+	appendCodeFenceStart(lines, context);
+	lines.push(getSignatureLine(signature));
+	appendCodeFenceEnd(lines, context);
+	appendSignatureParameters(lines, signature);
+	appendSignatureReturn(lines, signature);
+	return lines.join("\n");
+}
+function appendCodeFenceStart(lines, context) {
+	if (context.config.markdown.codeBlocks) lines.push("```typescript");
+}
+function appendCodeFenceEnd(lines, context) {
+	if (context.config.markdown.codeBlocks) lines.push("```");
+}
+function getSignatureLine(signature) {
+	const typeParameters = renderTypeParameterNames(signature.typeParameters);
+	const parameters = renderSignatureParameters(signature);
+	const returnType = signature.type == null ? "" : `: ${signature.type.toString()}`;
+	return `function ${signature.name}${typeParameters}(${parameters})${returnType}`;
+}
+function renderTypeParameterNames(typeParameters) {
+	if (typeParameters == null || typeParameters.length === 0) return "";
+	return `<${typeParameters.map((item) => item.name).join(", ")}>`;
+}
+function renderSignatureParameters(signature) {
+	return (signature.parameters ?? []).map((parameter) => {
+		const optional = parameter.flags.isOptional ? "?" : "";
+		const type = parameter.type == null ? "" : `: ${parameter.type.toString()}`;
+		return `${parameter.name}${optional}${type}`;
+	}).join(", ");
+}
+function appendSignatureParameters(lines, signature) {
+	const parameters = signature.parameters ?? [];
+	if (parameters.length === 0) return;
+	lines.push("");
+	lines.push("### Parameters");
+	lines.push("");
+	lines.push("| Name | Type | Description |");
+	lines.push("|------|------|-------------|");
+	for (const parameter of parameters) lines.push(renderSignatureParameterRow(parameter));
+}
+function renderSignatureParameterRow(parameter) {
+	const optional = parameter.flags.isOptional ? " (optional)" : "";
+	const type = parameter.type == null ? "-" : `\`${parameter.type.toString()}\``;
+	const summary = parameter.comment?.summary;
+	const description = summary == null ? "-" : renderCommentShort(summary);
+	return `| ${parameter.name}${optional} | ${type} | ${description} |`;
+}
+function appendSignatureReturn(lines, signature) {
+	const returnType = signature.type;
+	if (returnType == null || returnType.toString() === "void") return;
+	lines.push("");
+	lines.push("### Returns");
+	lines.push("");
+	lines.push(`\`${returnType.toString()}\``);
+	const returnTag = signature.comment?.blockTags.find((tag) => tag.tag === "@returns");
+	if (returnTag == null) return;
+	lines.push("");
+	lines.push(renderComment(returnTag.content));
+}
+function renderProperty(property) {
+	const lines = [];
+	const flags = getPropertyFlags(property);
+	lines.push(`### ${property.name}`);
+	if (flags.length > 0) lines.push(`*${flags.join(", ")}*`);
+	lines.push("");
+	appendPropertyType(lines, property);
+	appendPropertySummary(lines, property);
+	appendPropertyDefaultValue(lines, property);
+	return lines.join("\n");
+}
+function getPropertyFlags(property) {
+	const flags = [];
+	if (property.flags.isOptional) flags.push("optional");
+	if (property.flags.isReadonly) flags.push("readonly");
+	if (property.flags.isStatic) flags.push("static");
+	return flags;
+}
+function appendPropertyType(lines, property) {
+	if (property.type == null) return;
+	lines.push("```typescript");
+	lines.push(`${property.name}: ${property.type.toString()}`);
+	lines.push("```");
+	lines.push("");
+}
+function appendPropertySummary(lines, property) {
+	const summary = property.comment?.summary;
+	if (summary != null) lines.push(renderComment(summary));
+}
+function appendPropertyDefaultValue(lines, property) {
+	if (property.defaultValue == null || property.defaultValue.length === 0) return;
+	lines.push("");
+	lines.push(`**Default:** \`${property.defaultValue}\``);
+}
+function renderMethod(context, method) {
+	const lines = [];
+	lines.push(`### ${method.name}()`);
+	lines.push("");
+	const signatures = method.signatures ?? [];
+	for (const signature of signatures) appendMethodSignature(lines, context, signature);
+	return lines.join("\n");
+}
+function appendMethodSignature(lines, context, signature) {
+	const summary = signature.comment?.summary;
+	if (summary != null) {
+		lines.push(renderComment(summary));
+		lines.push("");
+	}
+	lines.push(renderSignature(context, signature));
+	lines.push("");
+}
+function renderTypeParameters(typeParameters) {
+	const lines = [];
+	lines.push("| Name | Constraint | Default | Description |");
+	lines.push("|------|------------|---------|-------------|");
+	for (const typeParameter of typeParameters) lines.push(renderTypeParameterRow(typeParameter));
+	return lines.join("\n");
+}
+function renderTypeParameterRow(typeParameter) {
+	const constraint = typeParameter.type == null ? "-" : `\`${typeParameter.type.toString()}\``;
+	const defaultValue = typeParameter.default == null ? "-" : `\`${typeParameter.default.toString()}\``;
+	const summary = typeParameter.comment?.summary;
+	const description = summary == null ? "-" : renderCommentShort(summary);
+	return `| ${typeParameter.name} | ${constraint} | ${defaultValue} | ${description} |`;
+}
+function renderHierarchy(reflection) {
+	const lines = [];
+	appendHierarchySection(lines, "**Extends:**", reflection.extendedTypes);
+	appendHierarchySection(lines, "**Implements:**", reflection.implementedTypes);
+	appendHierarchySection(lines, "**Extended by:**", reflection.extendedBy);
+	appendHierarchySection(lines, "**Implemented by:**", reflection.implementedBy);
+	return lines.length === 0 ? null : lines.join("\n");
+}
+function appendHierarchySection(lines, title, types) {
+	if (types == null || types.length === 0) return;
+	lines.push(title);
+	for (const item of types) lines.push(`- \`${item.toString()}\``);
+}
+//#endregion
+//#region src/typedoc/generator-pages-grouped.ts
+function generateGroupedFunctionsPage(params) {
+	const { context, functions, sourceFile } = params;
+	const moduleName = getModuleNameFromPath(sourceFile, context.packageNameCache);
+	return {
+		content: createGroupedFunctionsContent({
+			context,
+			functions,
+			moduleName,
+			sourceFile
+		}),
+		frontmatter: {
+			description: `Functions from ${sourceFile}`,
+			title: `${moduleName} Functions`
+		},
+		path: `functions/${getSlug(moduleName)}.md`
+	};
+}
+function createGroupedFunctionsContent(params) {
+	const { context, functions, moduleName, sourceFile } = params;
+	const lines = [
+		`# ${moduleName} Functions`,
+		"",
+		`Functions exported from \`${sourceFile}\``,
+		""
+	];
+	const sortedFunctions = sortReflectionsByName(functions);
+	for (const fn of sortedFunctions) appendGroupedFunction(lines, context, fn);
+	return lines.join("\n");
+}
+function appendGroupedFunction(lines, context, fn) {
+	lines.push(`## ${fn.name}`);
+	lines.push("");
+	const summary = fn.comment?.summary;
+	if (summary != null) {
+		lines.push(renderComment(summary));
+		lines.push("");
+	}
+	const signatures = fn.signatures ?? [];
+	for (const signature of signatures) {
+		lines.push(renderSignature(context, signature));
+		lines.push("");
+	}
+	appendExamples(lines, fn);
+	appendSourceLink(lines, context, fn);
+	lines.push("---");
+	lines.push("");
+}
+function appendExamples(lines, reflection) {
+	const examples = (reflection.comment?.blockTags ?? []).filter((tag) => tag.tag === "@example");
+	if (examples.length === 0) return;
+	lines.push("### Example");
+	lines.push("");
+	for (const example of examples) {
+		lines.push(renderComment(example.content));
+		lines.push("");
+	}
+}
+function appendSourceLink(lines, context, reflection) {
+	if (!context.config.markdown.sourceLinks) return;
+	const source = reflection.sources?.[0];
+	if (source == null) return;
+	const sourceUrl = getSourceUrl(context.config.markdown.sourceBaseUrl, source.fileName, source.line);
+	if (sourceUrl == null) return;
+	lines.push(`[Source](${sourceUrl})`);
+	lines.push("");
+}
+function generateGroupedTypesPage(params) {
+	const { context, sourceFile, types } = params;
+	const moduleName = getModuleNameFromPath(sourceFile, context.packageNameCache);
+	return {
+		content: createGroupedTypesContent({
+			context,
+			moduleName,
+			sourceFile,
+			types
+		}),
+		frontmatter: {
+			description: `Type definitions from ${sourceFile}`,
+			title: `${moduleName} Types`
+		},
+		path: `types/${getSlug(moduleName)}.md`
+	};
+}
+function createGroupedTypesContent(params) {
+	const { context, moduleName, sourceFile, types } = params;
+	const lines = [
+		`# ${moduleName} Types`,
+		"",
+		`Type definitions from \`${sourceFile}\``,
+		""
+	];
+	const sortedTypes = sortReflectionsByName(types);
+	for (const typeAlias of sortedTypes) appendGroupedType(lines, context, typeAlias);
+	return lines.join("\n");
+}
+function appendGroupedType(lines, context, typeAlias) {
+	lines.push(`## ${typeAlias.name}`);
+	lines.push("");
+	const summary = typeAlias.comment?.summary;
+	if (summary != null) {
+		lines.push(renderComment(summary));
+		lines.push("");
+	}
+	if (typeAlias.type != null) {
+		lines.push("```typescript");
+		lines.push(`type ${typeAlias.name} = ${typeAlias.type.toString()}`);
+		lines.push("```");
+		lines.push("");
+	}
+	appendSourceLink(lines, context, typeAlias);
+	lines.push("---");
+	lines.push("");
+}
+//#endregion
+//#region src/typedoc/generator-pages-index.ts
+function generateIndexPage(context, grouped) {
+	const lines = [
+		`# ${context.config.sidebar.title}`,
+		"",
+		getProjectSummary(context),
+		""
+	];
+	appendComponentSection(lines, context, grouped.componentItems);
+	appendFunctionsSection(lines, context, grouped.functionsByFile);
+	appendTypesSection(lines, context, grouped.typesByFile);
+	appendStandaloneSections(lines, context, grouped.standaloneItems);
+	return {
+		content: lines.join("\n"),
+		frontmatter: {
+			description: "Auto-generated API documentation",
+			sidebar_position: 0,
+			title: context.config.sidebar.title
+		},
+		path: "index.md"
+	};
+}
+function getProjectSummary(context) {
+	const summary = context.project.comment?.summary;
+	if (summary == null) return "Auto-generated API documentation.";
+	return renderComment(summary);
+}
+function appendComponentSection(lines, context, components) {
+	if (components.length === 0) return;
+	lines.push("## Components");
+	lines.push("");
+	for (const component of sortReflectionsByName(components)) {
+		const description = component.comment?.summary;
+		const suffix = description == null ? "" : ` - ${renderCommentShort(description)}`;
+		const link = buildLink(context.basePath, "components", getSlug(component.name));
+		lines.push(`- [${component.name}](${link})${suffix}`);
+	}
+	lines.push("");
+}
+function appendFunctionsSection(lines, context, functionsByFile) {
+	if (functionsByFile.size === 0) return;
+	lines.push("## Functions");
+	lines.push("");
+	lines.push(...renderModuleSectionItems(context, functionsByFile, "functions"));
+	lines.push("");
+}
+function appendTypesSection(lines, context, typesByFile) {
+	if (typesByFile.size === 0) return;
+	lines.push("## Type Aliases");
+	lines.push("");
+	lines.push(...renderModuleSectionItems(context, typesByFile, "types"));
+	lines.push("");
+}
+function renderModuleSectionItems(context, modules, category) {
+	return [...modules.entries()].sort(([left], [right]) => {
+		const leftName = getModuleNameFromPath(left, context.packageNameCache);
+		const rightName = getModuleNameFromPath(right, context.packageNameCache);
+		return leftName.localeCompare(rightName);
+	}).map(([sourceFile, items]) => {
+		const moduleName = getModuleNameFromPath(sourceFile, context.packageNameCache);
+		const itemNames = items.map((item) => item.name).sort().join(", ");
+		return `- [${moduleName}](${buildLink(context.basePath, category, getSlug(moduleName))}) - ${itemNames}`;
+	});
+}
+function appendStandaloneSections(lines, context, standaloneItems) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const item of standaloneItems) appendToMapList(groups, getKindGroupName(item.kind, item.name), item);
+	for (const groupName of [
+		"Interfaces",
+		"Classes",
+		"Variables",
+		"Enums",
+		"Other"
+	]) {
+		const groupItems = groups.get(groupName);
+		if (groupItems == null || groupItems.length === 0) continue;
+		appendStandaloneGroup({
+			context,
+			groupItems,
+			groupName,
+			lines
+		});
+	}
+}
+function appendStandaloneGroup(params) {
+	const { context, groupItems, groupName, lines } = params;
+	lines.push(`## ${groupName}`);
+	lines.push("");
+	for (const item of sortReflectionsByName(groupItems)) {
+		const description = item.comment?.summary;
+		const suffix = description == null ? "" : ` - ${renderCommentShort(description)}`;
+		const prefix = groupName.toLowerCase();
+		const link = buildLink(context.basePath, prefix, getSlug(item.name));
+		lines.push(`- [${item.name}](${link})${suffix}`);
+	}
+	lines.push("");
+}
+//#endregion
+//#region src/typedoc/generator-reflection-tags.ts
+function appendReflectionCommentTags(lines, reflection) {
+	const blockTags = reflection.comment?.blockTags ?? [];
+	appendTagExamples(lines, blockTags);
+	appendTagDeprecated(lines, blockTags);
+	appendTagSeeAlso(lines, blockTags);
+}
+function appendTagExamples(lines, blockTags) {
+	const examples = blockTags.filter((tag) => tag.tag === "@example");
+	if (examples.length === 0) return;
+	lines.push("## Examples");
+	lines.push("");
+	for (const example of examples) {
+		lines.push(renderComment(example.content));
+		lines.push("");
+	}
+}
+function appendTagDeprecated(lines, blockTags) {
+	const deprecatedTag = blockTags.find((tag) => tag.tag === "@deprecated");
+	if (deprecatedTag == null) return;
+	lines.push("<Warning title=\"Deprecated\">");
+	lines.push(renderComment(deprecatedTag.content));
+	lines.push("</Warning>");
+	lines.push("");
+}
+function appendTagSeeAlso(lines, blockTags) {
+	const seeTags = blockTags.filter((tag) => tag.tag === "@see");
+	if (seeTags.length === 0) return;
+	lines.push("## See Also");
+	lines.push("");
+	for (const seeTag of seeTags) lines.push(`- ${renderComment(seeTag.content)}`);
+	lines.push("");
+}
+//#endregion
+//#region src/typedoc/generator-reflection.ts
+function generateReflectionDocs(params) {
+	const { context, navigation, parentPath, reflection } = params;
+	const pagePath = getReflectionPagePath(reflection, parentPath);
+	const docs = [generateReflectionPage({
+		context,
+		navigation,
+		pagePath,
+		reflection
+	})];
+	const childRefs = reflection.children ?? [];
+	for (const child of childRefs) if (hasOwnPage(child.kind)) docs.push(...generateReflectionDocs({
+		context,
+		navigation: {
+			next: null,
+			prev: null
+		},
+		parentPath: pagePath,
+		reflection: child
+	}));
+	return docs;
+}
+function getReflectionPagePath(reflection, parentPath) {
+	const slug = getSlug(reflection.name);
+	if (parentPath.length > 0) return `${parentPath}/${slug}`;
+	const prefix = getGroupUrlPrefix(reflection.kind);
+	return prefix.length === 0 ? slug : `${prefix}/${slug}`;
+}
+function hasOwnPage(kind) {
+	return [
+		ReflectionKind.Class,
+		ReflectionKind.Enum,
+		ReflectionKind.Interface,
+		ReflectionKind.Module,
+		ReflectionKind.Namespace
+	].includes(kind);
+}
+function generateReflectionPage(params) {
+	const { context, navigation, pagePath, reflection } = params;
+	const lines = [];
+	appendReflectionSections({
+		context,
+		lines,
+		navigation,
+		pagePath,
+		reflection
+	});
+	return {
+		content: lines.join("\n"),
+		frontmatter: {
+			description: reflection.comment?.summary == null ? `${getKindName(reflection.kind)} ${reflection.name}` : renderCommentShort(reflection.comment.summary),
+			title: reflection.name
+		},
+		path: `${pagePath}.md`
+	};
+}
+function appendReflectionSections(params) {
+	const { context, lines, navigation, pagePath, reflection } = params;
+	appendBreadcrumbs(lines, context, pagePath);
+	appendTitle(lines, reflection);
+	appendDescription(lines, reflection);
+	appendTypeParameters(lines, reflection);
+	appendHierarchy(lines, context, reflection);
+	appendSignatures(lines, context, reflection);
+	appendProperties(lines, reflection);
+	appendMethods(lines, context, reflection);
+	appendEnumMembers(lines, reflection);
+	appendTypeAlias(lines, reflection);
+	appendSourceSection(lines, context, reflection);
+	appendReflectionCommentTags(lines, reflection);
+	appendNavigation({
+		context,
+		lines,
+		navigation,
+		reflection
+	});
+}
+function appendBreadcrumbs(lines, context, pagePath) {
+	if (!context.config.markdown.breadcrumbs) return;
+	lines.push(createBreadcrumbs(context.basePath, pagePath));
+	lines.push("");
+}
+function appendTitle(lines, reflection) {
+	const kind = getKindName(reflection.kind);
+	lines.push(`# ${kind}: ${reflection.name}`);
+	lines.push("");
+}
+function appendDescription(lines, reflection) {
+	const summary = reflection.comment?.summary;
+	if (summary == null) return;
+	lines.push(renderComment(summary));
+	lines.push("");
+}
+function appendTypeParameters(lines, reflection) {
+	const typeParameters = reflection.typeParameters ?? [];
+	if (typeParameters.length === 0) return;
+	lines.push("## Type Parameters");
+	lines.push("");
+	lines.push(renderTypeParameters(typeParameters));
+	lines.push("");
+}
+function appendHierarchy(lines, context, reflection) {
+	if (!context.config.markdown.hierarchy) return;
+	const hierarchy = renderHierarchy(reflection);
+	if (hierarchy == null) return;
+	lines.push("## Hierarchy");
+	lines.push("");
+	lines.push(hierarchy);
+	lines.push("");
+}
+function appendSignatures(lines, context, reflection) {
+	const signatures = reflection.signatures ?? [];
+	if (signatures.length === 0) return;
+	lines.push("## Signature");
+	lines.push("");
+	for (const signature of signatures) {
+		lines.push(renderSignature(context, signature));
+		lines.push("");
+	}
+}
+function appendProperties(lines, reflection) {
+	const properties = (reflection.children ?? []).filter((child) => child.kind === ReflectionKind.Property);
+	if (properties.length === 0) return;
+	lines.push("## Properties");
+	lines.push("");
+	for (const property of properties) {
+		lines.push(renderProperty(property));
+		lines.push("");
+	}
+}
+function appendMethods(lines, context, reflection) {
+	const methods = (reflection.children ?? []).filter((child) => child.kind === ReflectionKind.Method);
+	if (methods.length === 0) return;
+	lines.push("## Methods");
+	lines.push("");
+	for (const method of methods) {
+		lines.push(renderMethod(context, method));
+		lines.push("");
+	}
+}
+function appendEnumMembers(lines, reflection) {
+	const enumMembers = (reflection.children ?? []).filter((child) => child.kind === ReflectionKind.EnumMember);
+	if (enumMembers.length === 0) return;
+	lines.push("## Members");
+	lines.push("");
+	lines.push("| Member | Value | Description |");
+	lines.push("|--------|-------|-------------|");
+	for (const member of enumMembers) {
+		const value = member.defaultValue ?? "";
+		const summary = member.comment?.summary;
+		const description = summary == null ? "" : renderCommentShort(summary);
+		lines.push(`| \`${member.name}\` | \`${value}\` | ${description} |`);
+	}
+	lines.push("");
+}
+function appendTypeAlias(lines, reflection) {
+	if (reflection.kind !== ReflectionKind.TypeAlias || reflection.type == null) return;
+	lines.push("## Type");
+	lines.push("");
+	lines.push("```typescript");
+	lines.push(`type ${reflection.name} = ${reflection.type.toString()}`);
+	lines.push("```");
+	lines.push("");
+}
+function appendSourceSection(lines, context, reflection) {
+	if (!context.config.markdown.sourceLinks) return;
+	const source = reflection.sources?.[0];
+	if (source == null) return;
+	lines.push("## Source");
+	lines.push("");
+	const sourceUrl = getSourceUrl(context.config.markdown.sourceBaseUrl, source.fileName, source.line);
+	if (sourceUrl == null) lines.push(`${source.fileName}:${source.line}`);
+	else lines.push(`[${source.fileName}:${source.line}](${sourceUrl})`);
+	lines.push("");
+}
+function appendNavigation(params) {
+	const { context, lines, navigation, reflection } = params;
+	const line = createNavigationLine({
+		basePath: context.basePath,
+		kind: reflection.kind,
+		navigation
+	});
+	if (line == null) return;
+	lines.push("---");
+	lines.push("");
+	lines.push(line);
+	lines.push("");
+}
+//#endregion
+//#region src/typedoc/generator-docs.ts
+function generateMarkdownDocs(context) {
+	const grouped = groupProjectChildren(context.project, isReactComponent);
+	const docs = [generateIndexPage(context, grouped)];
+	addGroupedFunctionPages(context, docs, grouped.functionsByFile);
+	addGroupedTypePages(context, docs, grouped.typesByFile);
+	addComponentPages(context, docs, grouped.componentItems);
+	addStandalonePages(context, docs, grouped.standaloneItems);
+	docs.push(...generateCategoryIndexPages(context, grouped));
+	return docs;
+}
+function addGroupedFunctionPages(context, docs, functionsByFile) {
+	for (const [sourceFile, functions] of functionsByFile) docs.push(generateGroupedFunctionsPage({
+		context,
+		functions,
+		sourceFile
+	}));
+}
+function addGroupedTypePages(context, docs, typesByFile) {
+	for (const [sourceFile, types] of typesByFile) docs.push(generateGroupedTypesPage({
+		context,
+		sourceFile,
+		types
+	}));
+}
+function addComponentPages(context, docs, componentItems) {
+	const sorted = sortReflectionsByName(componentItems);
+	for (const [index, component] of sorted.entries()) docs.push(generateComponentPage({
+		component,
+		context,
+		navigation: getNavigation(sorted, index)
+	}));
+}
+function addStandalonePages(context, docs, standaloneItems) {
+	const itemsByKind = groupStandaloneByKind(standaloneItems);
+	for (const items of itemsByKind.values()) {
+		const sorted = sortReflectionsByName(items);
+		for (const [index, reflection] of sorted.entries()) docs.push(...generateReflectionDocs({
+			context,
+			navigation: getNavigation(sorted, index),
+			parentPath: "",
+			reflection
+		}));
+	}
+}
+function groupStandaloneByKind(standaloneItems) {
+	const itemsByKind = /* @__PURE__ */ new Map();
+	for (const item of standaloneItems) {
+		const existing = itemsByKind.get(item.kind) ?? [];
+		existing.push(item);
+		itemsByKind.set(item.kind, existing);
+	}
+	return itemsByKind;
+}
+function getNavigation(sortedItems, index) {
+	return {
+		next: index < sortedItems.length - 1 ? sortedItems[index + 1] : null,
+		prev: index > 0 ? sortedItems[index - 1] : null
+	};
+}
+//#endregion
+//#region src/typedoc/generator.ts
+var TypeDocGenerator = class {
+	basePath;
+	config;
+	packageNameCache = /* @__PURE__ */ new Map();
+	constructor(config) {
+		this.config = resolveTypeDocConfig(config);
+		this.basePath = `/${this.config.out}`;
+	}
+	async generate(outputDir) {
+		await this.populatePackageNameCache();
+		const project = await (await Application.bootstrapWithPlugins(getTypedocOptions(this.config), [new TSConfigReader(), new TypeDocReader()])).convert();
+		if (project == null) throw new Error("TypeDoc conversion failed");
+		const docs = generateMarkdownDocs({
+			basePath: this.basePath,
+			config: this.config,
+			packageNameCache: this.packageNameCache,
+			project
+		});
+		await this.writeDocs(outputDir, docs);
+		return docs;
+	}
+	async populatePackageNameCache() {
+		for (const entryPoint of this.config.entryPoints) await this.resolvePackageName(entryPoint);
+	}
+	async resolvePackageName(filePath) {
+		const directory = path.dirname(path.resolve(filePath));
+		if (this.packageNameCache.has(directory)) return this.packageNameCache.get(directory);
+		const packageName = (await readPackageUp({ cwd: directory }))?.packageJson.name;
+		const resolvedName = packageName == null || packageName.length === 0 ? void 0 : packageName.replace(/^@[^/]+\//u, "");
+		this.packageNameCache.set(directory, resolvedName);
+		return resolvedName;
+	}
+	async writeDocs(outputDir, docs) {
+		const apiDirectory = path.join(outputDir, this.config.out);
+		await fs.rm(apiDirectory, {
+			force: true,
+			recursive: true
+		});
+		await fs.mkdir(apiDirectory, { recursive: true });
+		for (const doc of docs) await this.writeSingleDoc(apiDirectory, doc);
+	}
+	async writeSingleDoc(apiDirectory, doc) {
+		const filePath = path.join(apiDirectory, doc.path);
+		await fs.mkdir(path.dirname(filePath), { recursive: true });
+		const frontmatter = createFrontmatter(doc);
+		await fs.writeFile(filePath, `${frontmatter}${doc.content}`);
+	}
+};
+function createFrontmatter(doc) {
+	const lines = ["---", `title: ${doc.frontmatter.title}`];
+	if (doc.frontmatter.description != null && doc.frontmatter.description.length > 0) lines.push(`description: ${doc.frontmatter.description}`);
+	if (doc.frontmatter.sidebar_position != null) lines.push(`sidebar_position: ${doc.frontmatter.sidebar_position}`);
+	if (doc.frontmatter.sidebar === false) lines.push("sidebar: false");
+	lines.push("---", "");
+	return `${lines.join("\n")}\n`;
+}
+async function generateApiDocs(config, outputDir) {
+	return new TypeDocGenerator(config).generate(outputDir);
+}
+//#endregion
+export { generateApiDocs as n, TypeDocGenerator as t };
+
+//# sourceMappingURL=generator-DcUomVnD.js.map