vuepress-jsdoc 5.0.0 → 6.1.0

package/dist/lib/parser.js

@@ -1,165 +1,223 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeContentToFile = exports.parseVueFile = exports.parseFile = void 0;
 /*
  * @vuepress
  * ---
  * headline: lib/parser.ts
  * ---
  */
-const jsdoc_to_markdown_1 = __importDefault(require("jsdoc-to-markdown"));
-const mkdirp_1 = require("mkdirp");
-const promises_1 = __importDefault(require("node:fs/promises"));
-const node_path_1 = require("node:path");
-const compileTemplates_1 = __importDefault(require("vue-docgen-cli/lib/compileTemplates"));
-const docgen_1 = require("vue-docgen-cli/lib/docgen");
-const constants_1 = require("../constants");
-const comment_parser_1 = require("./comment-parser");
+import jsdoc2md from 'jsdoc-to-markdown';
+import fs from 'node:fs/promises';
+import nodeModule, { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { StatisticType, TYPESCRIPT_EXTENSIONS, VUE_EXTENSIONS } from '../constants.js';
+import { parseVuepressFileHeader } from './comment-parser.js';
+const require = createRequire(import.meta.url);
+const TEMPLATE_FOLDER = fileURLToPath(new URL('../../template/', import.meta.url));
 /**
- * Parse a typescript or javascript file
- * @param file {DirectoryFile}
- * @param srcFolder {string}
- * @param destFolder {string}
- * @param configPath {string}
- * @param partials {string | string[]}
- * @returns {object} file data
+ * Get the folder of the generated markdown file
+ * @param {DirectoryFile} file
+ * @param {string} srcFolder
+ * @param {string} destFolder
+ * @returns {string} destination folder
  */
-const parseFile = (file, srcFolder, destFolder, configPath, partials) => __awaiter(void 0, void 0, void 0, function* () {
-    if (!file.folder)
-        return null;
-    const root = process.cwd();
-    const relativePathDest = (0, node_path_1.join)(destFolder, file.folder.replace(srcFolder, ''));
-    const folderInDest = (0, node_path_1.join)(root, relativePathDest);
-    const folderInSrc = (0, node_path_1.join)(root, file.folder);
-    let success = true;
-    let empty = false;
-    let excluded = false;
-    let fileContent = '';
-    // parse file
+export const getDestFolder = (file, srcFolder, destFolder) => path.join(destFolder, path.relative(path.resolve(srcFolder), path.resolve(file.folder)));
+/**
+ * Get a readable error message
+ * @param {unknown} error
+ * @returns {string}
+ */
+const getErrorMessage = (error) => (error instanceof Error ? error.message : String(error)).split('\n').filter(Boolean).slice(0, 3).join('\n');
+/**
+ * Remove TypeScript types from source code, so jsdoc is able to parse it.
+ * Types are replaced with whitespace, so all comments and line numbers stay intact.
+ * @param {string} code TypeScript code
+ * @returns {string} JavaScript code
+ */
+export const stripTypes = (code) => {
+    const { stripTypeScriptTypes } = nodeModule;
+    if (typeof stripTypeScriptTypes !== 'function') {
+        throw new Error('TypeScript files need Node.js >= 22.13 or a jsdoc config (--jsDocConfigPath)');
+    }
+    // stripTypeScriptTypes is still experimental and would print a warning
+    const emitWarning = process.emitWarning;
+    process.emitWarning = () => { };
     try {
-        let content = '';
-        let fileName = file.name;
-        if (fileName.endsWith('index')) {
-            fileName = 'index';
-        }
-        content = yield jsdoc_to_markdown_1.default.render({
-            'no-cache': configPath ? true : false,
-            files: [(0, node_path_1.join)(process.cwd(), file.folder, fileName + file.ext)],
-            configure: configPath,
-            partial: [
-                (0, node_path_1.resolve)(__filename, '../../../template/header.hbs'),
-                (0, node_path_1.resolve)(__filename, '../../../template/main.hbs'),
-                ...partials
-            ]
-        });
-        fileContent = (0, comment_parser_1.parseVuepressFileHeader)(yield promises_1.default.readFile(`${(0, node_path_1.join)(folderInSrc, fileName + file.ext)}`, 'utf-8'), file);
-        if (content) {
-            fileContent += content;
-        }
-        else {
-            empty = true;
-        }
+        return stripTypeScriptTypes(code, { mode: 'strip' });
     }
     catch (e) {
-        success = false;
-        excluded = true;
+        throw new Error(getErrorMessage(e), { cause: e });
     }
-    return {
-        success,
-        file,
-        empty,
-        excluded,
-        relativePathDest,
-        relativePathSrc: file.folder,
-        dest: folderInDest,
-        content: fileContent
-    };
-});
-exports.parseFile = parseFile;
+    finally {
+        process.emitWarning = emitWarning;
+    }
+};
 /**
- * Parse a vue file
- * @param {DirectoryFile} file
- * @param {string} srcFolder
- * @param {string} destFolder
- * @returns {object} file data
+ * Load the TypeScript compiler API. The project of the user is preferred over the bundled one.
+ * `typescript` >= 7 has no JavaScript API anymore, so `@typescript/typescript6` is tried as well.
+ * The result is cached, because it is used for every TypeScript file.
+ * @returns {TypeScriptApi | null} TypeScript module or null if it is not installed
+ */
+let typescript;
+const loadTypeScript = () => {
+    if (typescript !== undefined)
+        return typescript;
+    const requires = [createRequire(path.join(process.cwd(), 'package.json')), require];
+    for (const req of requires) {
+        for (const name of ['typescript', '@typescript/typescript6']) {
+            try {
+                const ts = req(name);
+                if (typeof ts?.transpileModule === 'function')
+                    return (typescript = ts);
+            }
+            catch {
+                // try the next one
+            }
+        }
+    }
+    return (typescript = null);
+};
+/**
+ * Transpile TypeScript with the TypeScript compiler. Comments and JSX are preserved.
+ * This supports syntax that type stripping can not handle: `enum`, `namespace`, parameter properties and JSX.
+ * @param {string} code TypeScript code
+ * @param {string} fileName used to detect `.tsx`
+ * @returns {string | null} JavaScript code or null if TypeScript is not installed
  */
-const parseVueFile = (file, srcFolder, destFolder) => __awaiter(void 0, void 0, void 0, function* () {
-    if (!file.folder)
+const transpileTypes = (code, fileName) => {
+    const ts = loadTypeScript();
+    if (!ts)
         return null;
-    const root = process.cwd();
-    const relativePathDest = (0, node_path_1.join)(destFolder, file.folder.replace(srcFolder, ''));
-    const folderInDest = (0, node_path_1.join)(root, relativePathDest);
-    const folderInSrc = (0, node_path_1.join)(root, file.folder);
-    const vueDocGenCliConf = yield (0, docgen_1.extractConfig)((0, node_path_1.join)(root, file.folder));
-    const config = Object.assign(Object.assign({}, vueDocGenCliConf), { components: file.name + file.ext });
-    let success = true;
-    let empty = false;
-    let fileContent = '';
-    try {
-        let fileName = file.name;
-        if (fileName.endsWith('index')) {
-            fileName = 'index';
+    return ts.transpileModule(code, {
+        fileName,
+        reportDiagnostics: false,
+        compilerOptions: {
+            target: ts.ScriptTarget.ESNext,
+            module: ts.ModuleKind.ESNext,
+            jsx: ts.JsxEmit.Preserve,
+            removeComments: false,
+            verbatimModuleSyntax: false,
+            isolatedModules: true
         }
-        // parse file
-        const data = yield (0, compileTemplates_1.default)('add', (0, node_path_1.join)(config.componentsRoot, fileName + file.ext), config, fileName + file.ext);
-        fileContent = (0, comment_parser_1.parseVuepressFileHeader)(yield promises_1.default.readFile(`${(0, node_path_1.join)(folderInSrc, fileName + file.ext)}`, 'utf-8'), file);
-        if (data.content) {
-            fileContent += data.content;
+    }).outputText;
+};
+/**
+ * Convert TypeScript to JavaScript. Type stripping of Node.js is used first, because it keeps all line numbers.
+ * If the file contains syntax which needs a transformation, the TypeScript compiler is used.
+ * @param {string} code TypeScript code
+ * @param {string} fileName
+ * @returns {string} JavaScript code
+ */
+export const typescriptToJavaScript = (code, fileName) => {
+    let reason = 'JSX can not be stripped';
+    if (!fileName.endsWith('.tsx')) {
+        try {
+            return stripTypes(code);
         }
-        else {
-            empty = true;
+        catch (e) {
+            reason = getErrorMessage(e);
         }
     }
-    catch (e) {
-        console.log(e);
-        success = false;
-    }
-    return {
-        success,
-        file,
-        empty,
-        relativePathDest,
-        relativePathSrc: file.folder,
-        dest: folderInDest,
-        content: fileContent
-    };
-});
-exports.parseVueFile = parseVueFile;
+    const transpiled = transpileTypes(code, fileName);
+    if (transpiled !== null)
+        return transpiled;
+    throw new Error(`${reason}\nInstall typescript or use a jsdoc config with babel (--jsDocConfigPath) for this file.`);
+};
+/**
+ * Escape vue interpolations (`{{ }}`) outside of code, because VuePress compiles every page as a vue template.
+ * @param {string} markdown
+ * @returns {string} escaped markdown
+ */
+export const escapeVueInterpolation = (markdown) => markdown
+    // split by fenced code blocks, <code> and <pre> tags and inline code
+    .split(/(```[\s\S]*?```|<pre[\s\S]*?<\/pre>|<code>[\s\S]*?<\/code>|`[^`\n]*`)/)
+    // odd parts are code, which is kept. Inside <code> tags vue still interpolates.
+    .map((part, i) => i % 2 === 1 && !part.startsWith('<code>')
+    ? part
+    : part.replace(/\{\{/g, '&#123;&#123;').replace(/\}\}/g, '&#125;&#125;'))
+    .join('');
 /**
- * Write content on disk
- * @param {ParseReturn | null} parseData
- * @param {string} dest
- * @returns {Promise | null} null or type with some data of the saved file
+ * Render a javascript or typescript file with jsdoc-to-markdown
+ * @param {DirectoryFile} file
+ * @param {ParseOptions} options
+ * @param {string} source content of the file
+ * @returns {Promise<string>} markdown
  */
-const writeContentToFile = (parseData, dest) => __awaiter(void 0, void 0, void 0, function* () {
-    const root = process.cwd();
-    dest = (0, node_path_1.join)(root, dest);
-    let type = constants_1.StatisticType.ERROR;
-    if (parseData === null || parseData === void 0 ? void 0 : parseData.excluded) {
-        type = constants_1.StatisticType.EXCLUDE;
+const renderScript = async (file, options, source) => {
+    const absolutePath = path.resolve(file.path);
+    const jsdocOptions = {
+        partial: [
+            path.join(TEMPLATE_FOLDER, 'header.hbs'),
+            path.join(TEMPLATE_FOLDER, 'main.hbs'),
+            ...(options.partials || [])
+        ]
+    };
+    if (options.jsDocConfigPath) {
+        // the user config takes care of the file (e.g. typescript via jsdoc-babel)
+        jsdocOptions.files = [absolutePath];
+        jsdocOptions.configure = path.resolve(options.jsDocConfigPath);
+        jsdocOptions['no-cache'] = true;
+    }
+    else if (TYPESCRIPT_EXTENSIONS.includes(file.ext)) {
+        jsdocOptions.source = typescriptToJavaScript(source, file.path);
+    }
+    else {
+        jsdocOptions.files = [absolutePath];
     }
+    return jsdoc2md.render(jsdocOptions);
+};
+/**
+ * Render a vue file with vue-docgen-cli
+ * @param {DirectoryFile} file
+ * @returns {Promise<string>} markdown
+ */
+const renderVue = async (file) => {
+    const { default: compileTemplates } = require('vue-docgen-cli/lib/compileTemplates');
+    const { extractConfig } = require('vue-docgen-cli/lib/docgen');
+    const fileName = path.basename(file.path);
+    const config = await extractConfig(path.resolve(file.folder));
+    const { content } = await compileTemplates('add', path.join(config.componentsRoot, fileName), config, fileName);
+    return content;
+};
+/**
+ * Parse a javascript, typescript or vue file and create the markdown content
+ * @param {DirectoryFile} file
+ * @param {ParseOptions} options
+ * @returns {Promise<ParseReturn>} file data
+ */
+export const parseFile = async (file, options) => {
+    const dest = getDestFolder(file, options.srcFolder, options.destFolder);
+    const empty = { type: StatisticType.EMPTY, file, dest, content: '' };
     try {
-        if (parseData === null || parseData === void 0 ? void 0 : parseData.content) {
-            const path = `${(0, node_path_1.join)(dest, parseData.file.name)}.md`;
-            yield (0, mkdirp_1.mkdirp)(dest);
-            yield promises_1.default.writeFile(path, parseData.content, 'utf-8');
-            type = (parseData === null || parseData === void 0 ? void 0 : parseData.empty) ? constants_1.StatisticType.EMPTY : constants_1.StatisticType.INCLUDE;
-        }
-        return Object.assign(Object.assign({}, parseData), { type });
+        const source = await fs.readFile(file.path, 'utf-8');
+        const isVue = VUE_EXTENSIONS.includes(file.ext);
+        const content = isVue ? await renderVue(file) : await renderScript(file, options, source);
+        if (!content?.trim())
+            return empty;
+        return {
+            type: StatisticType.INCLUDE,
+            file,
+            dest,
+            content: parseVuepressFileHeader(source, file) + escapeVueInterpolation(content.trim()) + '\n'
+        };
     }
-    catch (_a) { }
-    return null;
-});
-exports.writeContentToFile = writeContentToFile;
+    catch (e) {
+        const error = getErrorMessage(e);
+        // the file is excluded by the jsdoc config (source.excludePattern)
+        if (/no input files to process/i.test(error))
+            return empty;
+        return { ...empty, type: StatisticType.ERROR, error };
+    }
+};
+/**
+ * Write the parsed content to disk. Files without content are skipped.
+ * @param {ParseReturn} parseData
+ * @returns {Promise<string | null>} path of the written file or null
+ */
+export const writeContentToFile = async (parseData) => {
+    if (parseData.type !== StatisticType.INCLUDE || !parseData.content)
+        return null;
+    const filePath = path.join(parseData.dest, `${parseData.file.name}.md`);
+    await fs.mkdir(parseData.dest, { recursive: true });
+    await fs.writeFile(filePath, parseData.content, 'utf-8');
+    return filePath;
+};

package/dist/lib/vue-sidebar.d.ts

@@ -1,26 +1,66 @@
-/**
- * Runs through the given tree structure and creates a vuepress config
- * @param {object} data Information to build config
- * @param {array} data.fileTree tree structure
- * @param {string} data.codeFolder ./code/ folder
- * @param {string} data.srcFolder ./src/ folder
- * @param {string} data.docsFolder ./documentation/ folder
- * @param {string} data.title title string
- * @returns {object} returns the vuepress menu structure
- */
-export declare const generateVueSidebar: ({ fileTree, codeFolder, srcFolder, docsFolder, title }: {
-    fileTree: any;
+import { FileTree } from '../interfaces.js';
+export interface SidebarGroup {
+    text: string;
+    collapsible: boolean;
+    children: SidebarItem[];
+}
+export type SidebarItem = string | {
+    text: string;
+    link: string;
+} | SidebarGroup;
+export interface SidebarOptions {
+    /** tree structure, created by `listFolder` */
+    fileTree: FileTree[];
+    /** name of the folder inside the vuepress folder, e.g. `code` */
     codeFolder: string;
+    /** source folder, e.g. `src` */
     srcFolder: string;
+    /** folder of the generated markdown files, e.g. `documentation/code` */
     docsFolder: string;
+    /** title of the first sidebar group */
     title: string;
-}) => {
-    [x: string]: {
-        text: string;
-        collapsable: boolean;
-        children: {
-            link: string;
-            text: string;
-        }[];
-    }[];
+    /** sidebar format of the generated `config.js` */
+    format?: SiteFormat;
+    /** text of the first entry, which links to the readme */
+    readmeTitle?: string;
+    /** make the top level groups collapsible. Nested folders are always collapsible. */
+    collapsible?: boolean;
+}
+export type SiteFormat = 'vuepress' | 'vitepress';
+/**
+ * Get the route of the generated folder, e.g. `/code/`
+ * @param {string} codeFolder
+ * @returns {string}
+ */
+export declare const getSidebarBase: (codeFolder: string) => string;
+export interface VitepressSidebarItem {
+    text: string;
+    link?: string;
+    collapsed?: boolean;
+    items?: VitepressSidebarItem[];
+}
+/**
+ * Runs through the given tree structure and creates a vuepress 2 sidebar config.
+ * Only pages that were generated are linked. Folders become nested sidebar groups.
+ * @param {SidebarOptions} data Information to build config
+ * @returns {object} returns the vuepress sidebar structure
+ */
+export declare const generateVueSidebar: ({ fileTree, codeFolder, srcFolder, docsFolder, title, readmeTitle, collapsible }: SidebarOptions) => {
+    [x: string]: SidebarGroup[];
 };
+/**
+ * Runs through the given tree structure and creates a vitepress sidebar config.
+ * Vitepress needs the text of every link, so it is read from the generated page.
+ * @param {SidebarOptions} data Information to build config
+ * @returns {object} returns the vitepress sidebar structure
+ */
+export declare const generateVitepressSidebar: (data: SidebarOptions) => {
+    [x: string]: VitepressSidebarItem[];
+};
+/**
+ * Create the content of the `config.js`, which is placed into the generated folder.
+ * It exports the file tree and a `sidebarTree(title)` function, which returns the vuepress or vitepress sidebar.
+ * @param {SidebarOptions} options
+ * @returns {string} javascript code (ES module)
+ */
+export declare const createSidebarConfig: (options: SidebarOptions) => string;

package/dist/lib/vue-sidebar.js

@@ -1,59 +1,125 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateVueSidebar = void 0;
 /*
  * @vuepress
  * ---
  * headline: lib/vue-sidebar.ts
  * ---
  */
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = require("node:path");
+import fs from 'node:fs';
+import path from 'node:path';
+import { SIDEBAR_TITLE_PLACEHOLDER } from '../constants.js';
+import { getPageName, normalizePath } from './list-folder.js';
+/**
+ * Get the route of the generated folder, e.g. `/code/`
+ * @param {string} codeFolder
+ * @returns {string}
+ */
+export const getSidebarBase = (codeFolder) => `/${normalizePath(codeFolder)}/`;
 /**
- * Runs through the given tree structure and creates a vuepress config
- * @param {object} data Information to build config
- * @param {array} data.fileTree tree structure
- * @param {string} data.codeFolder ./code/ folder
- * @param {string} data.srcFolder ./src/ folder
- * @param {string} data.docsFolder ./documentation/ folder
- * @param {string} data.title title string
- * @returns {object} returns the vuepress menu structure
+ * Runs through the given tree structure and creates a vuepress 2 sidebar config.
+ * Only pages that were generated are linked. Folders become nested sidebar groups.
+ * @param {SidebarOptions} data Information to build config
+ * @returns {object} returns the vuepress sidebar structure
  */
-const generateVueSidebar = ({ fileTree, codeFolder, srcFolder, docsFolder, title }) => {
-    let rootFiles = [{ link: `/${codeFolder}/`, text: '::vuepress-jsdoc-title::' }];
-    rootFiles = rootFiles.concat(fileTree.filter((file) => !file.children).map((file) => `/${(0, node_path_1.join)(codeFolder, file.name)}`));
-    const rootFolder = fileTree.filter((file) => file.children && file.children.length > 0);
-    const buildChildren = (children, name, depth) => {
-        let newChildren = [];
+export const generateVueSidebar = ({ fileTree, codeFolder, srcFolder, docsFolder, title, readmeTitle = SIDEBAR_TITLE_PLACEHOLDER, collapsible = false }) => {
+    const base = getSidebarBase(codeFolder);
+    const root = normalizePath(srcFolder);
+    const toLink = (file) => {
+        if (!file.fullPath)
+            return null;
+        const relativePath = path.posix.relative(root, normalizePath(file.fullPath));
+        if (!fs.existsSync(`${path.join(docsFolder, relativePath)}.md`))
+            return null;
+        return `${base}${relativePath}`;
+    };
+    const buildChildren = (children) => {
+        const items = [];
         for (const child of children) {
-            if (child.children && child.children.length > 0) {
-                newChildren = newChildren.concat(buildChildren(child.children, child.name, depth + 1));
-            }
-            else if (child.fullPath) {
-                const path = child.fullPath.replace(srcFolder, '');
-                if (node_fs_1.default.existsSync(`${(0, node_path_1.join)(docsFolder, path)}.md`)) {
-                    newChildren.push(`/${(0, node_path_1.join)(codeFolder, path)}`);
+            if (child.children) {
+                const nested = buildChildren(child.children);
+                if (nested.length > 0) {
+                    items.push({ text: child.name, collapsible: true, children: nested });
                 }
             }
+            else {
+                const link = toLink(child);
+                if (link)
+                    items.push(link);
+            }
         }
-        return newChildren;
+        return items;
     };
-    const tree = rootFolder.map((folder) => ({
-        text: folder.name,
-        collapsable: false,
-        children: buildChildren(folder.children, folder.name, 0)
-    }));
+    const rootFiles = [
+        { text: readmeTitle, link: base },
+        ...buildChildren(fileTree.filter((file) => !file.children))
+    ];
+    const folders = fileTree
+        .filter((file) => file.children)
+        .map((folder) => ({ text: folder.name, collapsible, children: buildChildren(folder.children) }))
+        .filter((group) => group.children.length > 0);
     return {
-        [`/${codeFolder}/`]: [
-            {
-                text: title,
-                collapsable: false,
-                children: rootFiles
-            }
-        ].concat(tree)
+        [base]: [{ text: title, collapsible, children: rootFiles }, ...folders]
+    };
+};
+/**
+ * Get the `title` of the frontmatter of a generated page (set with the `@vuepress` block)
+ * @param {string} mdPath path to the generated markdown file
+ * @returns {string|undefined}
+ */
+const readPageTitle = (mdPath) => {
+    const title = /^---\r?\n[\s\S]*?^title:\s*(.+?)\s*$[\s\S]*?^---/m.exec(fs.readFileSync(mdPath, 'utf-8'))?.[1];
+    return title?.replace(/^(['"])(.*)\1$/, '$2');
+};
+/**
+ * Runs through the given tree structure and creates a vitepress sidebar config.
+ * Vitepress needs the text of every link, so it is read from the generated page.
+ * @param {SidebarOptions} data Information to build config
+ * @returns {object} returns the vitepress sidebar structure
+ */
+export const generateVitepressSidebar = (data) => {
+    const base = getSidebarBase(data.codeFolder);
+    const root = normalizePath(data.srcFolder);
+    // the frontmatter title or the file name. Index files are shown as `index` instead of their prefixed page name.
+    const getText = (link) => {
+        const relativePath = link.slice(base.length);
+        const name = path.posix.basename(relativePath);
+        const isIndex = name === getPageName(path.posix.join(root, path.posix.dirname(relativePath)), 'index');
+        return readPageTitle(`${path.join(data.docsFolder, relativePath)}.md`) ?? (isIndex ? 'index' : name);
+    };
+    const toVitepressItem = (item, nested = true) => {
+        if (typeof item === 'string') {
+            return { text: getText(item), link: item };
+        }
+        if ('link' in item) {
+            return { text: item.text, link: item.link };
+        }
+        return {
+            text: item.text,
+            // nested folders are collapsed, vitepress opens groups with the active page.
+            // collapsible top level groups stay open.
+            ...(item.collapsible ? { collapsed: nested } : {}),
+            items: item.children.map((child) => toVitepressItem(child))
+        };
     };
+    return { [base]: generateVueSidebar(data)[base].map((group) => toVitepressItem(group, false)) };
+};
+/**
+ * Create the content of the `config.js`, which is placed into the generated folder.
+ * It exports the file tree and a `sidebarTree(title)` function, which returns the vuepress or vitepress sidebar.
+ * @param {SidebarOptions} options
+ * @returns {string} javascript code (ES module)
+ */
+export const createSidebarConfig = (options) => {
+    // the placeholder is replaced with the `title` parameter of `sidebarTree`
+    const data = { ...options, readmeTitle: SIDEBAR_TITLE_PLACEHOLDER };
+    const tree = options.format === 'vitepress' ? generateVitepressSidebar(data) : generateVueSidebar(data);
+    const sidebar = JSON.stringify(tree, null, 2).replace(JSON.stringify(SIDEBAR_TITLE_PLACEHOLDER), 'title');
+    return [
+        '// This file is generated by vuepress-jsdoc. Do not edit it manually.',
+        `export const fileTree = ${JSON.stringify(options.fileTree, null, 2)};`,
+        '',
+        `export const sidebarTree = (title = 'Mainpage') => (${sidebar});`,
+        '',
+        'export default sidebarTree;',
+        ''
+    ].join('\n');
 };
-exports.generateVueSidebar = generateVueSidebar;