Signed-off-by: Goran Draganić <goran@daytona.io> Signed-off-by: MDzaja <mirkodzaja0@gmail.com>
622 lines
19 KiB
JavaScript
622 lines
19 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
// Copyright Daytona Platforms Inc.
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
const fs = require('fs')
|
|
const path = require('path')
|
|
|
|
const SDK_SOURCE_DIR = path.resolve(__dirname, '../src/main/java/io/daytona/sdk')
|
|
const DOCS_OUTPUT_DIR = path.resolve(__dirname, '../../../apps/docs/src/content/docs/en/java-sdk')
|
|
|
|
const DOC_TARGETS = [
|
|
{ outputFile: 'daytona.mdx', logName: 'Daytona', classes: [{ file: 'Daytona.java', className: 'Daytona' }] },
|
|
{
|
|
outputFile: 'config.mdx',
|
|
logName: 'DaytonaConfig',
|
|
classes: [{ file: 'DaytonaConfig.java', className: 'DaytonaConfig', includeInner: ['Builder'] }],
|
|
},
|
|
{ outputFile: 'sandbox.mdx', logName: 'Sandbox', classes: [{ file: 'Sandbox.java', className: 'Sandbox' }] },
|
|
{
|
|
outputFile: 'process.mdx',
|
|
logName: 'Process',
|
|
classes: [{ file: 'Process.java', className: 'Process' }],
|
|
},
|
|
{
|
|
outputFile: 'file-system.mdx',
|
|
logName: 'FileSystem',
|
|
classes: [{ file: 'FileSystem.java', className: 'FileSystem' }],
|
|
},
|
|
{ outputFile: 'git.mdx', logName: 'Git', classes: [{ file: 'Git.java', className: 'Git' }] },
|
|
{
|
|
outputFile: 'snapshot.mdx',
|
|
logName: 'SnapshotService',
|
|
classes: [{ file: 'SnapshotService.java', className: 'SnapshotService' }],
|
|
},
|
|
{
|
|
outputFile: 'volume-service.mdx',
|
|
logName: 'VolumeService',
|
|
classes: [{ file: 'VolumeService.java', className: 'VolumeService' }],
|
|
},
|
|
{ outputFile: 'image.mdx', logName: 'Image', classes: [{ file: 'Image.java', className: 'Image' }] },
|
|
{
|
|
outputFile: 'code-interpreter.mdx',
|
|
logName: 'CodeInterpreter',
|
|
classes: [
|
|
{ file: 'CodeInterpreter.java', className: 'CodeInterpreter' },
|
|
{ file: 'RunCodeOptions.java', className: 'RunCodeOptions' },
|
|
],
|
|
},
|
|
{
|
|
outputFile: 'lsp-server.mdx',
|
|
logName: 'LspServer',
|
|
classes: [{ file: 'LspServer.java', className: 'LspServer' }],
|
|
},
|
|
{
|
|
outputFile: 'computer-use.mdx',
|
|
logName: 'ComputerUse',
|
|
classes: [{ file: 'ComputerUse.java', className: 'ComputerUse' }],
|
|
},
|
|
{
|
|
outputFile: 'pty-handle.mdx',
|
|
logName: 'PtyHandle',
|
|
classes: [{ file: 'PtyHandle.java', className: 'PtyHandle' }],
|
|
},
|
|
{
|
|
outputFile: 'pty.mdx',
|
|
logName: 'PtyCreateOptions, PtyResult',
|
|
title: 'Pty',
|
|
classes: [
|
|
{ file: 'PtyCreateOptions.java', className: 'PtyCreateOptions' },
|
|
{ file: 'PtyResult.java', className: 'PtyResult' },
|
|
],
|
|
},
|
|
{
|
|
outputFile: 'errors.mdx',
|
|
logName: 'Exception Classes',
|
|
title: 'Errors',
|
|
classes: [
|
|
{ file: 'exception/DaytonaException.java', className: 'DaytonaException' },
|
|
{ file: 'exception/DaytonaAuthenticationException.java', className: 'DaytonaAuthenticationException' },
|
|
{ file: 'exception/DaytonaBadRequestException.java', className: 'DaytonaBadRequestException' },
|
|
{ file: 'exception/DaytonaConflictException.java', className: 'DaytonaConflictException' },
|
|
{ file: 'exception/DaytonaConnectionException.java', className: 'DaytonaConnectionException' },
|
|
{ file: 'exception/DaytonaForbiddenException.java', className: 'DaytonaForbiddenException' },
|
|
{ file: 'exception/DaytonaNotFoundException.java', className: 'DaytonaNotFoundException' },
|
|
{ file: 'exception/DaytonaRateLimitException.java', className: 'DaytonaRateLimitException' },
|
|
{ file: 'exception/DaytonaServerException.java', className: 'DaytonaServerException' },
|
|
{ file: 'exception/DaytonaTimeoutException.java', className: 'DaytonaTimeoutException' },
|
|
{ file: 'exception/DaytonaValidationException.java', className: 'DaytonaValidationException' },
|
|
],
|
|
},
|
|
]
|
|
|
|
function ensureDir(dir) {
|
|
fs.mkdirSync(dir, { recursive: true })
|
|
}
|
|
|
|
function readUtf8(filePath) {
|
|
return fs.readFileSync(filePath, 'utf8')
|
|
}
|
|
|
|
function normalizeWhitespace(value) {
|
|
return String(value || '')
|
|
.replace(/\s+/g, ' ')
|
|
.trim()
|
|
}
|
|
|
|
function escapeType(type) {
|
|
if (!type) return 'Object'
|
|
return String(type).replace(/</g, '\\<').replace(/>/g, '\\>')
|
|
}
|
|
|
|
function splitTopLevel(value, separator) {
|
|
const parts = []
|
|
const source = String(value || '')
|
|
if (!source.trim()) return parts
|
|
|
|
let buffer = ''
|
|
let angle = 0
|
|
let paren = 0
|
|
let square = 0
|
|
|
|
for (let i = 0; i < source.length; i += 1) {
|
|
const c = source[i]
|
|
|
|
if (c === '<') angle += 1
|
|
if (c === '>') angle = Math.max(0, angle - 1)
|
|
if (c === '(') paren += 1
|
|
if (c === ')') paren = Math.max(0, paren - 1)
|
|
if (c === '[') square += 1
|
|
if (c === ']') square = Math.max(0, square - 1)
|
|
|
|
if (c === separator && angle === 0 && paren === 0 && square === 0) {
|
|
parts.push(buffer.trim())
|
|
buffer = ''
|
|
continue
|
|
}
|
|
|
|
buffer += c
|
|
}
|
|
|
|
if (buffer.trim()) parts.push(buffer.trim())
|
|
return parts
|
|
}
|
|
|
|
function cleanJavadocInline(text) {
|
|
return String(text || '')
|
|
.replace(/\{@code\s+([^}]*)\}/g, '`$1`')
|
|
.replace(/\{@link\s+([^}]*)\}/g, '`$1`')
|
|
.replace(/<\/?code>/g, '`')
|
|
.trim()
|
|
}
|
|
|
|
function parseJavadoc(raw) {
|
|
if (!raw) return { description: '', params: {}, returns: '', throws: [] }
|
|
|
|
const lines = raw
|
|
.replace(/^\s*\/\*\*/, '')
|
|
.replace(/\*\/\s*$/, '')
|
|
.split('\n')
|
|
.map((line) => line.replace(/^\s*\*\s?/, '').trimEnd())
|
|
|
|
const descriptionLines = []
|
|
const params = {}
|
|
let returns = ''
|
|
const throws = []
|
|
let currentTag = null
|
|
|
|
for (const rawLine of lines) {
|
|
const line = rawLine.trim()
|
|
|
|
if (!line) {
|
|
if (!currentTag) descriptionLines.push('')
|
|
continue
|
|
}
|
|
|
|
if (line.startsWith('@param ')) {
|
|
const body = line.replace(/^@param\s+/, '')
|
|
const idx = body.indexOf(' ')
|
|
const name = idx === -1 ? body.trim() : body.slice(0, idx).trim()
|
|
const text = idx === -1 ? '' : body.slice(idx + 1).trim()
|
|
params[name] = text
|
|
currentTag = { kind: 'param', name }
|
|
continue
|
|
}
|
|
|
|
if (line.startsWith('@return')) {
|
|
returns = line.replace(/^@return\s*/, '').trim()
|
|
currentTag = { kind: 'return' }
|
|
continue
|
|
}
|
|
|
|
if (line.startsWith('@throws ') || line.startsWith('@exception ')) {
|
|
const body = line.replace(/^@(throws|exception)\s+/, '')
|
|
const idx = body.indexOf(' ')
|
|
const type = idx === -1 ? body.trim() : body.slice(0, idx).trim()
|
|
const text = idx === -1 ? '' : body.slice(idx + 1).trim()
|
|
throws.push({ type, description: text })
|
|
currentTag = { kind: 'throws', index: throws.length - 1 }
|
|
continue
|
|
}
|
|
|
|
if (line.startsWith('@')) {
|
|
currentTag = null
|
|
continue
|
|
}
|
|
|
|
if (!currentTag) {
|
|
descriptionLines.push(line)
|
|
continue
|
|
}
|
|
|
|
if (currentTag.kind === 'param') {
|
|
const prev = params[currentTag.name] || ''
|
|
params[currentTag.name] = prev ? `${prev} ${line}` : line
|
|
continue
|
|
}
|
|
|
|
if (currentTag.kind === 'return') {
|
|
returns = returns ? `${returns} ${line}` : line
|
|
continue
|
|
}
|
|
|
|
if (currentTag.kind === 'throws') {
|
|
const prev = throws[currentTag.index].description
|
|
throws[currentTag.index].description = prev ? `${prev} ${line}` : line
|
|
}
|
|
}
|
|
|
|
const description = descriptionLines
|
|
.join('\n')
|
|
.replace(/\r/g, '')
|
|
.replace(/\n{3,}/g, '\n\n')
|
|
.replace(/[ \t]+$/gm, '')
|
|
.replace(/<pre>\s*\{@code\s*/g, '\n```java\n')
|
|
.replace(/\s*\}\s*<\/pre>/g, '\n```\n')
|
|
.replace(/<pre>/g, '\n```java\n')
|
|
.replace(/<\/pre>/g, '\n```\n')
|
|
.replace(/\{@code\s+([^}]*)\}/g, '`$1`')
|
|
.replace(/\{@link\s+([^}]*)\}/g, '`$1`')
|
|
.replace(/<\/?p>/g, '\n')
|
|
.replace(/<\/?code>/g, '`')
|
|
.trim()
|
|
|
|
return {
|
|
description,
|
|
params: Object.fromEntries(Object.entries(params).map(([k, v]) => [k, cleanJavadocInline(v)])),
|
|
returns: cleanJavadocInline(returns),
|
|
throws: throws.map((item) => ({
|
|
type: String(item.type || '').trim(),
|
|
description: cleanJavadocInline(item.description || ''),
|
|
})),
|
|
}
|
|
}
|
|
|
|
function findMatchingBrace(source, openBraceIndex) {
|
|
let depth = 0
|
|
for (let i = openBraceIndex; i < source.length; i += 1) {
|
|
if (source[i] === '{') depth += 1
|
|
if (source[i] === '}') depth -= 1
|
|
if (depth === 0) return i
|
|
}
|
|
return -1
|
|
}
|
|
|
|
function findClassBlock(source, className) {
|
|
const rx = new RegExp(
|
|
`((?:\\s*\/\\*\\*[\\s\\S]*?\\*\\/\\s*)?)\\s*public\\s+(?:static\\s+)?(?:final\\s+)?class\\s+${className}\\b[^\\{]*\\{`,
|
|
'm',
|
|
)
|
|
const match = rx.exec(source)
|
|
if (!match) return null
|
|
|
|
const start = match.index
|
|
const declaration = match[0]
|
|
const openBrace = start + declaration.lastIndexOf('{')
|
|
const closeBrace = findMatchingBrace(source, openBrace)
|
|
if (closeBrace < 0) return null
|
|
|
|
return {
|
|
className,
|
|
javadoc: parseJavadoc(match[1] || ''),
|
|
bodyStart: openBrace + 1,
|
|
bodyEnd: closeBrace,
|
|
body: source.slice(openBrace + 1, closeBrace),
|
|
}
|
|
}
|
|
|
|
function parseParameters(paramList) {
|
|
const params = []
|
|
for (const part of splitTopLevel(paramList || '', ',')) {
|
|
let token = normalizeWhitespace(part)
|
|
if (!token) continue
|
|
|
|
token = token.replace(/@[A-Za-z_][A-Za-z0-9_]*(?:\([^)]*\))?\s*/g, '')
|
|
token = token.replace(/\bfinal\b\s+/g, '').trim()
|
|
if (!token) continue
|
|
|
|
const items = token.split(/\s+/)
|
|
if (items.length < 2) {
|
|
params.push({ type: token, name: token })
|
|
continue
|
|
}
|
|
|
|
const name = items[items.length - 1].replace(/,$/, '').trim()
|
|
const type = items.slice(0, -1).join(' ').trim()
|
|
params.push({ type, name })
|
|
}
|
|
return params
|
|
}
|
|
|
|
function parsePublicMembers(classBlock) {
|
|
const fields = []
|
|
const constructors = []
|
|
const methods = []
|
|
|
|
const lines = classBlock.body.split('\n')
|
|
let depth = 1
|
|
let collecting = false
|
|
let commentBuffer = []
|
|
let pendingJavadocRaw = ''
|
|
|
|
for (const line of lines) {
|
|
const trimmed = line.trim()
|
|
const currentDepth = depth
|
|
|
|
if (!collecting && currentDepth === 1 && trimmed.startsWith('/**')) {
|
|
collecting = true
|
|
commentBuffer = [line]
|
|
if (trimmed.includes('*/')) {
|
|
collecting = false
|
|
pendingJavadocRaw = commentBuffer.join('\n')
|
|
}
|
|
} else if (collecting) {
|
|
commentBuffer.push(line)
|
|
if (trimmed.includes('*/')) {
|
|
collecting = false
|
|
pendingJavadocRaw = commentBuffer.join('\n')
|
|
}
|
|
} else if (currentDepth === 1) {
|
|
// Strip single-line method bodies: "public Type foo() { return x; }" → "public Type foo() {"
|
|
const normalized = normalizeWhitespace(trimmed).replace(/\{[^{}]*\}\s*$/, '{')
|
|
|
|
if (normalized.startsWith('public static class ') || normalized.startsWith('public class ')) {
|
|
pendingJavadocRaw = ''
|
|
} else if (
|
|
normalized.startsWith('public ') &&
|
|
!normalized.startsWith('public enum ') &&
|
|
!normalized.startsWith('public interface ')
|
|
) {
|
|
if (normalized.includes('(')) {
|
|
const constructorRx = new RegExp(
|
|
`^public\\s+${classBlock.className}\\s*\\(([^)]*)\\)\\s*(?:throws\\s+([^\\{]+))?\\s*\\{?$`,
|
|
)
|
|
const cMatch = normalized.match(constructorRx)
|
|
if (cMatch) {
|
|
constructors.push({
|
|
signature: `public ${classBlock.className}(${(cMatch[1] || '').trim()})${cMatch[2] ? ` throws ${normalizeWhitespace(cMatch[2])}` : ''}`,
|
|
parameters: parseParameters(cMatch[1]),
|
|
throwsTypes: splitTopLevel(cMatch[2] || '', ',').map((v) => normalizeWhitespace(v)),
|
|
javadoc: parseJavadoc(pendingJavadocRaw),
|
|
})
|
|
pendingJavadocRaw = ''
|
|
} else {
|
|
const mMatch = normalized.match(
|
|
/^public\s+(static\s+)?([\w<>, ?\[\].]+?)\s+(\w+)\s*\(([^)]*)\)\s*(?:throws\s+([^\{]+))?\s*\{?$/,
|
|
)
|
|
if (mMatch) {
|
|
methods.push({
|
|
name: mMatch[3],
|
|
returnType: normalizeWhitespace(mMatch[2]),
|
|
signature:
|
|
`public ${mMatch[1] || ''}${mMatch[2]} ${mMatch[3]}(${(mMatch[4] || '').trim()})${mMatch[5] ? ` throws ${normalizeWhitespace(mMatch[5])}` : ''}`
|
|
.replace(/\s+/g, ' ')
|
|
.trim(),
|
|
parameters: parseParameters(mMatch[4]),
|
|
throwsTypes: splitTopLevel(mMatch[5] || '', ',').map((v) => normalizeWhitespace(v)),
|
|
javadoc: parseJavadoc(pendingJavadocRaw),
|
|
})
|
|
pendingJavadocRaw = ''
|
|
}
|
|
}
|
|
} else if (normalized.endsWith(';')) {
|
|
const fMatch = normalized.match(
|
|
/^public\s+(?:static\s+)?(?:final\s+)?([\w<>, ?\[\].]+?)\s+(\w+)\s*(?:=.*)?;$/,
|
|
)
|
|
if (fMatch) {
|
|
fields.push({
|
|
name: fMatch[2],
|
|
type: normalizeWhitespace(fMatch[1]),
|
|
javadoc: parseJavadoc(pendingJavadocRaw),
|
|
})
|
|
pendingJavadocRaw = ''
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const c of line) {
|
|
if (c === '{') depth += 1
|
|
if (c === '}') depth -= 1
|
|
}
|
|
}
|
|
|
|
return { fields, constructors, methods }
|
|
}
|
|
|
|
function collectThrows(declaredThrows, javadocThrows) {
|
|
const merged = []
|
|
|
|
for (const type of declaredThrows || []) {
|
|
const match = (javadocThrows || []).find((t) => t.type.endsWith(type) || type.endsWith(t.type))
|
|
merged.push({ type, description: match ? match.description : '' })
|
|
}
|
|
|
|
for (const tag of javadocThrows || []) {
|
|
if (!merged.some((item) => item.type === tag.type)) merged.push(tag)
|
|
}
|
|
|
|
return merged
|
|
}
|
|
|
|
function pushParamsSection(lines, parameters, javadocParams) {
|
|
if (!parameters.length) return
|
|
lines.push('**Parameters**:')
|
|
lines.push('')
|
|
for (const param of parameters) {
|
|
const desc = (javadocParams && javadocParams[param.name]) || ''
|
|
lines.push(`- \`${param.name}\` _${escapeType(param.type)}_ - ${desc}`.trimEnd())
|
|
}
|
|
lines.push('')
|
|
}
|
|
|
|
function pushThrowsSection(lines, throwsList) {
|
|
if (!throwsList.length) return
|
|
lines.push('**Throws**:')
|
|
lines.push('')
|
|
for (const item of throwsList) {
|
|
lines.push(`- \`${escapeType(item.type)}\` - ${item.description || ''}`.trimEnd())
|
|
}
|
|
lines.push('')
|
|
}
|
|
|
|
function buildClassDoc(classData) {
|
|
const lines = []
|
|
lines.push(`## ${classData.className}`)
|
|
lines.push('')
|
|
|
|
const classDescription = classData.javadoc.description || `${classData.className} class for Daytona SDK.`
|
|
lines.push(classDescription)
|
|
lines.push('')
|
|
|
|
if (classData.fields.length) {
|
|
lines.push('**Properties**:')
|
|
lines.push('')
|
|
for (const field of classData.fields) {
|
|
lines.push(`- \`${field.name}\` _${escapeType(field.type)}_ - ${field.javadoc.description || ''}`.trimEnd())
|
|
}
|
|
lines.push('')
|
|
}
|
|
|
|
if (classData.constructors.length) {
|
|
lines.push('### Constructors')
|
|
lines.push('')
|
|
|
|
for (const ctor of classData.constructors) {
|
|
lines.push(`#### new ${classData.className}()`)
|
|
lines.push('')
|
|
lines.push('```java')
|
|
lines.push(ctor.signature)
|
|
lines.push('```')
|
|
lines.push('')
|
|
|
|
if (ctor.javadoc.description) {
|
|
lines.push(ctor.javadoc.description)
|
|
lines.push('')
|
|
}
|
|
|
|
pushParamsSection(lines, ctor.parameters, ctor.javadoc.params)
|
|
pushThrowsSection(lines, collectThrows(ctor.throwsTypes, ctor.javadoc.throws))
|
|
}
|
|
}
|
|
|
|
if (classData.methods.length) {
|
|
lines.push('### Methods')
|
|
lines.push('')
|
|
|
|
for (const method of classData.methods) {
|
|
lines.push(`#### ${method.name}()`)
|
|
lines.push('')
|
|
lines.push('```java')
|
|
lines.push(method.signature)
|
|
lines.push('```')
|
|
lines.push('')
|
|
|
|
if (method.javadoc.description) {
|
|
lines.push(method.javadoc.description)
|
|
lines.push('')
|
|
}
|
|
|
|
pushParamsSection(lines, method.parameters, method.javadoc.params)
|
|
|
|
if (method.returnType && method.returnType !== 'void') {
|
|
lines.push('**Returns**:')
|
|
lines.push('')
|
|
lines.push(`- \`${escapeType(method.returnType)}\` - ${method.javadoc.returns || ''}`.trimEnd())
|
|
lines.push('')
|
|
}
|
|
|
|
pushThrowsSection(lines, collectThrows(method.throwsTypes, method.javadoc.throws))
|
|
}
|
|
}
|
|
|
|
return lines.join('\n')
|
|
}
|
|
|
|
function renderFrontmatter(title) {
|
|
return `---\ntitle: "${title}"\nhideTitleOnPage: true\n---\n\n`
|
|
}
|
|
|
|
function postProcess(content) {
|
|
return (
|
|
String(content)
|
|
.replace(/\r/g, '')
|
|
.replace(/\n{3,}/g, '\n\n')
|
|
.replace(/```java\n\n/g, '```java\n')
|
|
.replace(/\n\n```/g, '\n```')
|
|
.replace(/[ \t]+$/gm, '')
|
|
.trim() + '\n'
|
|
)
|
|
}
|
|
|
|
function parseTopClass(fileRelativePath, className) {
|
|
const sourcePath = path.join(SDK_SOURCE_DIR, fileRelativePath)
|
|
if (!fs.existsSync(sourcePath)) throw new Error(`Source file not found: ${sourcePath}`)
|
|
|
|
const source = readUtf8(sourcePath)
|
|
const classBlock = findClassBlock(source, className)
|
|
if (!classBlock) throw new Error(`Class ${className} not found in ${fileRelativePath}`)
|
|
|
|
const members = parsePublicMembers(classBlock)
|
|
return {
|
|
className,
|
|
javadoc: classBlock.javadoc,
|
|
fields: members.fields,
|
|
constructors: members.constructors,
|
|
methods: members.methods,
|
|
source,
|
|
}
|
|
}
|
|
|
|
function parseInnerClass(parentSource, parentClassName, innerClassName) {
|
|
const parent = findClassBlock(parentSource, parentClassName)
|
|
if (!parent) return null
|
|
|
|
const classRx = new RegExp(`public\\s+(?:static\\s+)?class\\s+${innerClassName}\\b[^\\{]*\\{`, 'm')
|
|
const classMatch = classRx.exec(parent.body)
|
|
if (!classMatch) return null
|
|
|
|
const textBefore = parent.body.slice(0, classMatch.index)
|
|
const javadocRx = /\/\*\*(?:(?!\/\*\*)[\s\S])*?\*\/\s*$/
|
|
const javadocMatch = textBefore.match(javadocRx)
|
|
|
|
const relativeStart = classMatch.index
|
|
const declaration = classMatch[0]
|
|
const openBrace = parent.bodyStart + relativeStart + declaration.lastIndexOf('{')
|
|
const closeBrace = findMatchingBrace(parentSource, openBrace)
|
|
if (closeBrace < 0) return null
|
|
|
|
const body = parentSource.slice(openBrace + 1, closeBrace)
|
|
const block = { className: innerClassName, body }
|
|
const members = parsePublicMembers(block)
|
|
|
|
return {
|
|
className: `${parentClassName}.${innerClassName}`,
|
|
javadoc: parseJavadoc(javadocMatch ? javadocMatch[0] : ''),
|
|
fields: members.fields,
|
|
constructors: members.constructors,
|
|
methods: members.methods,
|
|
}
|
|
}
|
|
|
|
function generateTarget(target) {
|
|
console.log(`📝 Generating docs for ${target.logName}...`)
|
|
|
|
const classDocs = []
|
|
for (const classTarget of target.classes) {
|
|
const parsed = parseTopClass(classTarget.file, classTarget.className)
|
|
classDocs.push(parsed)
|
|
|
|
if (classTarget.includeInner && classTarget.includeInner.length) {
|
|
for (const innerName of classTarget.includeInner) {
|
|
const innerParsed = parseInnerClass(parsed.source, classTarget.className, innerName)
|
|
if (!innerParsed) throw new Error(`Inner class ${innerName} not found in ${classTarget.className}`)
|
|
classDocs.push(innerParsed)
|
|
}
|
|
}
|
|
}
|
|
|
|
const title = target.title || classDocs[0].className
|
|
const body = classDocs.map((item) => buildClassDoc(item)).join('\n\n')
|
|
const content = renderFrontmatter(title) + postProcess(body)
|
|
|
|
const outputPath = path.join(DOCS_OUTPUT_DIR, target.outputFile)
|
|
fs.writeFileSync(outputPath, content)
|
|
console.log(`✅ Generated: ${target.outputFile}`)
|
|
}
|
|
|
|
function main() {
|
|
console.log('🚀 Starting documentation generation...')
|
|
console.log(`📂 Output directory: ${DOCS_OUTPUT_DIR}`)
|
|
console.log('')
|
|
|
|
ensureDir(DOCS_OUTPUT_DIR)
|
|
for (const target of DOC_TARGETS) generateTarget(target)
|
|
|
|
console.log('')
|
|
console.log('✨ Documentation generation complete!')
|
|
}
|
|
|
|
if (require.main === module) main()
|