@versatiles/release-tool 1.2.6 → 2.0.0

package/README.md

@@ -3,13 +3,14 @@
 
 # VersaTiles Release Tools
 
-Tools used internally for:
+Tools used for:
 
-* creating Markdown documentation of TypeScript libraries: [`vrt ts2md`](#subcommand-vrt-ts2md)
-* creating Markdown documentation of executables: [`vrt cmd2md`](#subcommand-vrt-cmd2md)
-* inserting Markdown into documents: [`vrt insertmd`](#subcommand-vrt-insertmd)
-* updating "Table of Content" in Markdown files: [`vrt inserttoc`](#subcommand-vrt-inserttoc)
-* releasing the current version as npm package: [`vrt release-npm`](#subcommand-vrt-release-npm)
+* creating a graph of the source code as mermaid: [`vrt deps-graph`](#subcommand-vrt-deps-graph)
+* upgrading all package dependencies: [`vrt deps-upgrade`](#subcommand-vrt-deps-upgrade)
+* creating Markdown documentation of executables: [`vrt doc-command`](#subcommand-vrt-doc-command)
+* inserting Markdown into documents: [`vrt doc-insert`](#subcommand-vrt-doc-insert)
+* updating "Table of Content" in Markdown files: [`vrt doc-toc`](#subcommand-vrt-doc-toc)
+* releasing the project as npm package: [`vrt release-npm`](#subcommand-vrt-release-npm)
 
 # Installation
 
@@ -37,8 +38,6 @@ You need to configure the scripts in the package.json:
 * `scripts.prepack` is **recommended** to ensure that all files are up-to-date before releasing. Here you can build code and documentation.
 * `scripts.release` is **recommended** to make it easy to release a new version.
 
-Have a look at this [package.json](https://github.com/versatiles-org/node-release-tool/blob/main/package.json) as an example.
-
 # Command `vrt`
 
 <!--- This chapter is generated automatically --->
@@ -50,40 +49,49 @@ Usage: vrt [options] [command]
 versatiles release and documentaion tool
 
 Options:
-  -h, --help                              display help for command
+  -h, --help                                display help for command
 
 Commands:
-  ts2md <typescript> <tsconfig>           documents a TypeScript file and outputs it to stdout
-  cmd2md <command>                        documents a runnable command and outputs it to stdout
-  insertmd <readme> [heading] [foldable]  takes Markdown from stdin and insert it into a Markdown file
-  inserttoc <readme> [heading]            updates the TOC in a Markdown file
-  release-npm [path]                      release a npm package
-  help [command]                          display help for command
+  deps-graph                                draws a graph of all files in the project and outputs it as mermaid
+  deps-upgrade                              upgrades all dependencies to the latest version
+  doc-command <command>                     documents a runnable command and outputs it
+  doc-insert <readme> [heading] [foldable]  takes Markdown from stdin and insert it into a Markdown file
+  doc-toc <readme> [heading]                updates the TOC in a Markdown file
+  release-npm [path]                        releases a npm package
+  help [command]                            display help for command
 ```
 
-## Subcommand: `vrt ts2md`
+## Subcommand: `vrt deps-graph`
 
 ```console
-$ vrt ts2md
-Usage: vrt ts2md [options] <typescript> <tsconfig>
+$ vrt deps-graph
+Usage: vrt deps-graph [options]
 
-documents a TypeScript file and outputs it to stdout
+draws a graph of all files in the project and outputs it as mermaid
 
-Arguments:
-  typescript  Filename of the TypeScript file
-  tsconfig    Filename of tsconfig.json
+Options:
+  -h, --help  display help for command
+```
+
+## Subcommand: `vrt deps-upgrade`
+
+```console
+$ vrt deps-upgrade
+Usage: vrt deps-upgrade [options]
+
+upgrades all dependencies to the latest version
 
 Options:
   -h, --help  display help for command
 ```
 
-## Subcommand: `vrt cmd2md`
+## Subcommand: `vrt doc-command`
 
 ```console
-$ vrt cmd2md
-Usage: vrt cmd2md [options] <command>
+$ vrt doc-command
+Usage: vrt doc-command [options] <command>
 
-documents a runnable command and outputs it to stdout
+documents a runnable command and outputs it
 
 Arguments:
   command     command to run
@@ -92,11 +100,11 @@ Options:
   -h, --help  display help for command
 ```
 
-## Subcommand: `vrt insertmd`
+## Subcommand: `vrt doc-insert`
 
 ```console
-$ vrt insertmd
-Usage: vrt insertmd [options] <readme> [heading] [foldable]
+$ vrt doc-insert
+Usage: vrt doc-insert [options] <readme> [heading] [foldable]
 
 takes Markdown from stdin and insert it into a Markdown file
 
@@ -109,11 +117,11 @@ Options:
   -h, --help  display help for command
 ```
 
-## Subcommand: `vrt inserttoc`
+## Subcommand: `vrt doc-toc`
 
 ```console
-$ vrt inserttoc
-Usage: vrt inserttoc [options] <readme> [heading]
+$ vrt doc-toc
+Usage: vrt doc-toc [options] <readme> [heading]
 
 updates the TOC in a Markdown file
 
@@ -131,7 +139,7 @@ Options:
 $ vrt release-npm
 Usage: vrt release-npm [options] [path]
 
-release a npm package
+releases a npm package
 
 Arguments:
   path        root path of the Node.js project
@@ -139,3 +147,44 @@ Arguments:
 Options:
   -h, --help  display help for command
 ```
+
+# Development
+
+## Dependency Graph
+
+<!--- This chapter is generated automatically --->
+
+```mermaid
+flowchart TB
+
+subgraph 0["src"]
+subgraph 1["commands"]
+2["command.ts"]
+5["dependency-graph.ts"]
+7["markdown.ts"]
+8["release.ts"]
+B["upgrade-dependencies.ts"]
+end
+subgraph 3["lib"]
+4["utils.ts"]
+6["log.ts"]
+9["git.ts"]
+A["shell.ts"]
+end
+C["index.ts"]
+end
+2-->4
+5-->6
+7-->4
+8-->9
+8-->6
+8-->A
+9-->A
+B-->6
+B-->A
+C-->2
+C-->5
+C-->7
+C-->8
+C-->B
+```

package/dist/commands/dependency-graph.d.ts

@@ -0,0 +1 @@
+export declare function generateDependencyGraph(directory: string): Promise<void>;

package/dist/commands/dependency-graph.js

@@ -0,0 +1,21 @@
+import { cruise } from 'dependency-cruiser';
+import { panic } from '../lib/log.js';
+export async function generateDependencyGraph(directory) {
+    let cruiseResult;
+    try {
+        cruiseResult = await cruise([directory], {
+            includeOnly: '^src',
+            outputType: 'mermaid',
+            exclude: ["\\.(test|d)\\.ts$", "node_modules"],
+        });
+    }
+    catch (pError) {
+        panic(String(pError));
+    }
+    let { output } = cruiseResult;
+    if (typeof output !== 'string')
+        panic('no output');
+    output = output.replace('flowchart LR', 'flowchart TB');
+    process.stdout.write(Buffer.from('```mermaid\n' + output + '```\n'));
+}
+//# sourceMappingURL=dependency-graph.js.map

package/dist/commands/markdown.js

@@ -275,7 +275,7 @@ function nodesToHtml(children) {
     return children.map(nodeToHtml).join('');
 }
 function textToHtml(text) {
-    return text.replace(/[^a-z0-9 ,.-:_?@äöüß]/gi, c => `&#${c.charCodeAt(0)};`);
+    return text.replace(/[^a-z0-9 ,.\-:_?@äöüß]/gi, c => `&#${c.charCodeAt(0)};`);
 }
 export function parseMarkdown(document) {
     return remark().use(remarkGfm).parse(document);

package/dist/commands/upgrade-dependencies.d.ts

@@ -0,0 +1 @@
+export declare function upgradeDependencies(directory: string): Promise<void>;

package/dist/commands/upgrade-dependencies.js

@@ -0,0 +1,12 @@
+import { check, info } from '../lib/log.js';
+import { getShell } from '../lib/shell.js';
+export async function upgradeDependencies(directory) {
+    const shell = getShell(directory);
+    await check('Remove all dependencies', async () => {
+        await shell.run('rm -rf node_modules');
+        await shell.run('rm -f package-lock.json');
+    });
+    await check('Upgrade all dependencies', shell.stdout('npm update --save'));
+    info('All dependencies are up to date');
+}
+//# sourceMappingURL=upgrade-dependencies.js.map

package/dist/index.js

@@ -1,32 +1,35 @@
 #!/usr/bin/env -S node --enable-source-maps
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { generateTsMarkdownDoc } from './commands/typedoc.js';
 import { injectMarkdown, updateTOC } from './commands/markdown.js';
 import { Command, InvalidArgumentError } from 'commander';
 import { cwd } from 'node:process';
 import { generateCommandDocumentation } from './commands/command.js';
 import { release } from './commands/release.js';
+import { upgradeDependencies } from './commands/upgrade-dependencies.js';
+import { generateDependencyGraph } from './commands/dependency-graph.js';
 export const program = new Command();
 program
     .name('vrt')
     .description('versatiles release and documentaion tool');
-program.command('ts2md')
-    .description('documents a TypeScript file and outputs it to stdout')
-    .argument('<typescript>', 'Filename of the TypeScript file', checkFilename)
-    .argument('<tsconfig>', 'Filename of tsconfig.json', checkFilename)
-    .action(async (tsFilename, tsConfig) => {
-    const mdDocumentation = await generateTsMarkdownDoc([tsFilename], tsConfig);
-    process.stdout.write(mdDocumentation);
+program.command('deps-graph')
+    .description('draws a graph of all files in the project and outputs it as mermaid')
+    .action(() => {
+    void generateDependencyGraph(process.cwd());
+});
+program.command('deps-upgrade')
+    .description('upgrades all dependencies to the latest version')
+    .action(() => {
+    void upgradeDependencies(process.cwd());
 });
-program.command('cmd2md')
-    .description('documents a runnable command and outputs it to stdout')
+program.command('doc-command')
+    .description('documents a runnable command and outputs it')
     .argument('<command>', 'command to run')
     .action(async (command) => {
     const mdDocumentation = await generateCommandDocumentation(command);
     process.stdout.write(mdDocumentation);
 });
-program.command('insertmd')
+program.command('doc-insert')
     .description('takes Markdown from stdin and insert it into a Markdown file')
     .argument('<readme>', 'Markdown file, like a readme.md', checkFilename)
     .argument('[heading]', 'Heading in the Markdown file', '# API')
@@ -40,7 +43,7 @@ program.command('insertmd')
     mdFile = injectMarkdown(mdFile, mdContent, heading, foldable);
     writeFileSync(mdFilename, mdFile);
 });
-program.command('inserttoc')
+program.command('doc-toc')
     .description('updates the TOC in a Markdown file')
     .argument('<readme>', 'Markdown file, like a readme.md', checkFilename)
     .argument('[heading]', 'Heading in the Markdown file', '# Table of Content')
@@ -50,10 +53,10 @@ program.command('inserttoc')
     writeFileSync(mdFilename, mdFile);
 });
 program.command('release-npm')
-    .description('release a npm package')
+    .description('releases a npm package')
     .argument('[path]', 'root path of the Node.js project')
     .action((path) => {
-    void release(resolve(path ?? ',', process.cwd()), 'main');
+    void release(resolve(path ?? '.', process.cwd()), 'main');
 });
 if (process.env.NODE_ENV !== 'test') {
     await program.parseAsync();

package/dist/lib/log.d.ts

@@ -2,4 +2,4 @@ export declare function panic(text: string): never;
 export declare function warn(text: string): void;
 export declare function info(text: string): void;
 export declare function abort(): never;
-export declare function check<T>(message: string, promise: Promise<T>): Promise<T>;
+export declare function check<T>(message: string, promise: (Promise<T>) | (() => Promise<T>)): Promise<T>;

package/dist/lib/log.js

@@ -15,14 +15,14 @@ export function abort() {
 export async function check(message, promise) {
     process.stderr.write(`\x1b[0;90m\u2B95 ${message}\x1b[0m`);
     try {
-        const result = await promise;
+        const result = await (typeof promise === 'function' ? promise() : promise);
         process.stderr.write(`\r\x1b[0;92m\u2714 ${message}\x1b[0m\n`);
         return result;
     }
     catch (error) {
         process.stderr.write(`\r\x1b[0;91m\u2718 ${message}\x1b[0m\n`);
         panic(error.message);
-        throw Error();
+        throw error;
     }
 }
 //# sourceMappingURL=log.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@versatiles/release-tool",
-  "version": "1.2.6",
+  "version": "2.0.0",
   "description": "VersaTiles release and documentation tools",
   "bin": {
     "vrt": "./dist/index.js"
@@ -10,44 +10,44 @@
     "dist/**/*.d.ts"
   ],
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.build.json && chmod +x dist/index.js",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && chmod +x dist/index.js && npm run doc",
     "check": "npm run lint && npm run build && npm run test",
-    "doc": "npx vrt cmd2md vrt | npx vrt insertmd README.md '# Command'",
+    "dev": "tsx src/index.ts",
+    "doc": "npm run doc-command && npm run doc-graph",
+    "doc-command": "tsx src/index.ts doc-command vrt | tsx src/index.ts doc-insert README.md '# Command'",
+    "doc-graph": "tsx src/index.ts deps-graph | tsx src/index.ts doc-insert README.md '## Dependency Graph'",
     "lint": "eslint . --color",
-    "prepack": "npm run build && npm run doc",
-    "release": "npm run build && npx vrt release-npm",
+    "prepack": "npm run build",
+    "release": "npm run build && tsx src/index.ts release-npm",
     "test-coverage": "NODE_OPTIONS=--experimental-vm-modules jest --coverage",
     "test": "NODE_OPTIONS=--experimental-vm-modules jest",
-    "upgrade": "npm-check-updates -u && rm -f package-lock.json; rm -rf node_modules; npm i && npm update"
+    "upgrade": "tsx src/index.ts deps-upgrade"
   },
-  "author": "yetzt <node@yetzt.me>, Michael Kreil <versatiles@michael-kreil.de>",
+  "author": "Michael Kreil <versatiles@michael-kreil.de>",
   "license": "Unlicense",
   "type": "module",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/versatiles-org/node-versatiles.git"
+    "url": "git+https://github.com/versatiles-org/node-release-tool.git"
   },
-  "homepage": "https://github.com/versatiles-org/node-versatiles/blob/main/versatiles-release-tool/README.md",
+  "homepage": "https://github.com/versatiles-org/node-release-tool",
   "devDependencies": {
-    "@types/inquirer": "^9.0.7",
-    "@types/jest": "^29.5.13",
-    "@types/node": "^22.5.5",
-    "@typescript-eslint/eslint-plugin": "^8.6.0",
-    "@typescript-eslint/parser": "^8.6.0",
-    "eslint": "^9.11.0",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.13.5",
+    "@typescript-eslint/eslint-plugin": "^8.22.0",
+    "@typescript-eslint/parser": "^8.22.0",
+    "eslint": "^9.21.0",
     "jest": "^29.7.0",
-    "npm-check-updates": "^17.1.3",
     "ts-jest": "^29.2.5",
-    "ts-node": "^10.9.2",
-    "tsx": "^4.19.1",
-    "typescript": "^5.6.2",
-    "typescript-eslint": "^8.6.0"
+    "tsx": "^4.19.3",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.24.1"
   },
   "dependencies": {
-    "@inquirer/select": "^3.0.1",
-    "commander": "^12.1.0",
+    "@inquirer/select": "^4.0.9",
+    "commander": "^13.1.0",
+    "dependency-cruiser": "^16.10.0",
     "remark": "^15.0.1",
-    "remark-gfm": "^4.0.0",
-    "typedoc": "^0.26.7"
+    "remark-gfm": "^4.0.1"
   }
 }

package/dist/commands/typedoc.d.ts

@@ -1,6 +0,0 @@
-/**
- * Generate markdown documentation from TypeScript files.
- * @param sourceFilePaths - Array of absolute TypeScript file paths.
- * @param tsConfigPath - Absolute file path of tsconfig.json.
- */
-export declare function generateTsMarkdownDoc(sourceFilePaths: string[], tsConfigPath: string): Promise<string>;

package/dist/commands/typedoc.js

@@ -1,280 +0,0 @@
-import { Application, ReflectionKind, } from 'typedoc';
-/**
- * Generate markdown documentation from TypeScript files.
- * @param sourceFilePaths - Array of absolute TypeScript file paths.
- * @param tsConfigPath - Absolute file path of tsconfig.json.
- */
-export async function generateTsMarkdownDoc(sourceFilePaths, tsConfigPath) {
-    const app = await Application.bootstrap({ entryPoints: sourceFilePaths, tsconfig: tsConfigPath });
-    const project = await app.convert();
-    if (!project) {
-        throw new Error('Failed to convert TypeScript project.');
-    }
-    return Array.from(documentProject(project)).join('\n');
-}
-function* documentProject(project) {
-    if (!project.groups) {
-        throw new Error('No TypeScript code to document found! Is this a lib?');
-    }
-    for (const group of project.groups) {
-        yield '\n# ' + group.title;
-        for (const d of group.children) {
-            const declaration = d;
-            switch (declaration.kind) {
-                case ReflectionKind.Class:
-                    yield* documentClass(declaration);
-                    break;
-                case ReflectionKind.Function:
-                    yield* documentMethod(declaration, 2);
-                    break;
-                case ReflectionKind.Interface:
-                    yield* documentInterface(declaration);
-                    break;
-                case ReflectionKind.TypeAlias:
-                    yield* documentType(declaration);
-                    break;
-                case ReflectionKind.Variable:
-                    yield* documentVariable(declaration);
-                    break;
-                default:
-                    throw new Error('implement ' + declaration.kind);
-            }
-        }
-    }
-}
-function* documentInterface(declaration) {
-    yield `\n## Interface: \`${declaration.name}\`<a id="${createAnchorId(declaration)}"></a>`;
-    yield '\n```typescript';
-    yield 'interface {';
-    for (const child of declaration.children ?? []) {
-        if (child.kind !== ReflectionKind.Property)
-            throw Error('should be a property inside an interface');
-        if (child.type == null)
-            throw Error('should have a type');
-        const name = child.name + (child.flags.isOptional ? '?' : '');
-        yield `  ${name}: ${formatTypeDeclaration(child.type)};`;
-    }
-    yield '}';
-    yield '```';
-}
-function* documentType(declaration) {
-    yield `\n## Type: \`${declaration.name}\`<a id="${createAnchorId(declaration)}"></a>`;
-    if (declaration.type) {
-        yield `\n**Type:** <code>${formatTypeDeclaration(declaration.type)}</code>`;
-    }
-}
-function* documentClass(declaration) {
-    yield `\n## Class: \`${declaration.name}\`<a id="${createAnchorId(declaration)}"></a>`;
-    yield* documentSummaryBlock(declaration);
-    for (const group of declaration.groups ?? []) {
-        const publicMembers = group.children.filter(member => !member.flags.isPrivate && !member.flags.isProtected);
-        if (publicMembers.length === 0)
-            continue;
-        // Sort by order in code
-        publicMembers.sort((a, b) => a.id - b.id);
-        switch (group.title) {
-            case 'Constructors':
-                if (publicMembers.length !== 1)
-                    throw Error('publicMembers.length !== 1');
-                yield* documentMethod(publicMembers[0], 3, true);
-                continue;
-            case 'Accessors':
-                yield '\n### Accessors';
-                for (const member of publicMembers)
-                    yield documentAccessor(member);
-                continue;
-            case 'Properties':
-                yield '\n### Properties';
-                for (const member of publicMembers)
-                    yield documentProperty(member);
-                continue;
-            case 'Methods':
-                for (const member of publicMembers)
-                    yield* documentMethod(member, 3);
-                continue;
-            default:
-                console.log(group);
-                throw Error('Unknown group title');
-        }
-    }
-}
-function* documentMethod(method, depth, isConstructor = false) {
-    if (method.signatures?.length !== 1)
-        throw Error('should be 1');
-    const [signature] = method.signatures;
-    const methodName = signature.name;
-    const parameters = formatMethodParameters(signature.parameters ?? []);
-    const returnType = signature.type;
-    const methodType = isConstructor ? 'Constructor' : 'Method';
-    yield `\n${'#'.repeat(depth)} ${methodType}: \`${methodName}(${parameters})\``;
-    yield* documentSummaryBlock(signature);
-    if (signature.parameters && signature.parameters.length > 0) {
-        yield '';
-        yield '**Parameters:**';
-        for (const parameter of signature.parameters) {
-            yield documentProperty(parameter);
-        }
-    }
-    if (returnType && !isConstructor) {
-        yield `\n**Returns:** <code>${formatTypeDeclaration(returnType)}</code>`;
-    }
-}
-function formatMethodParameters(parameters) {
-    return parameters.map(param => param.name).join(', ');
-}
-// Helper Functions
-function getDeclarationKindName(kind) {
-    switch (kind) {
-        case ReflectionKind.Class: return 'Class';
-        case ReflectionKind.Function: return 'Function';
-        case ReflectionKind.Interface: return 'Interface';
-        case ReflectionKind.TypeAlias: return 'Type';
-        case ReflectionKind.Variable: return 'Variable';
-        default: throw new Error(`Unknown reflection kind: ${kind}`);
-    }
-}
-function documentProperty(ref) {
-    let line = `  - <code>${ref.name}${resolveTypeDeclaration(ref.type)}</code>`;
-    if (ref.flags.isOptional)
-        line += ' (optional)';
-    const summary = extractSummary(ref.comment);
-    if (summary != null)
-        line += '  \n    ' + summary;
-    return line;
-}
-function* documentVariable(ref) {
-    const prefix = ref.flags.isConst ? 'const' : 'let';
-    yield `\n## \`${prefix} ${ref.name}\``;
-    const summary = extractSummary(ref.comment);
-    if (summary != null)
-        yield summary;
-}
-function documentAccessor(ref) {
-    let line = `  - <code>${ref.name}${resolveTypeDeclaration(ref.type)}</code>`;
-    const summary = extractSummary(ref.comment);
-    if (summary != null)
-        line += '  \n    ' + summary;
-    return line;
-}
-function extractSummary(comment) {
-    if (!comment)
-        return null;
-    return comment.summary.map(line => line.text).join('');
-}
-function* documentSummaryBlock(ref) {
-    yield '';
-    if (ref.comment) {
-        yield formatComment(ref.comment);
-        return;
-    }
-    const { type } = ref;
-    if (type?.type === 'reflection') {
-        if (type.declaration.signatures?.length !== 1)
-            throw Error('type.declaration.signatures?.length !== 1');
-        const [signature] = type.declaration.signatures;
-        if (signature.comment) {
-            yield formatComment(signature.comment);
-            return;
-        }
-    }
-    const sourceLink = createSourceLink(ref);
-    if (sourceLink != null)
-        yield sourceLink;
-    return;
-    function formatComment(comment) {
-        let summary = extractSummary(comment) ?? '';
-        const link = createSourceLink(ref);
-        if (link != null)
-            summary += ' ' + link;
-        return summary.replace(/\n/m, '  \n') + '\n';
-    }
-}
-function resolveTypeDeclaration(someType) {
-    if (!someType)
-        return '';
-    return `: ${formatTypeDeclaration(someType)}`;
-}
-function formatTypeDeclaration(someType) {
-    return getTypeRec(someType);
-    function getTypeRec(some) {
-        switch (some.type) {
-            case 'intrinsic':
-                return some.name;
-            case 'literal':
-                return JSON.stringify(some.value);
-            case 'reference': {
-                let result = some.name;
-                if (some.reflection)
-                    result = `[${result}](#${createAnchorId(some.reflection)})`;
-                if (some.typeArguments?.length ?? 0)
-                    result += '&lt;'
-                        + (some.typeArguments ?? [])
-                            .map(getTypeRec).join(',')
-                        + '&gt;';
-                return result;
-            }
-            case 'reflection':
-                switch (some.declaration.kind) {
-                    case ReflectionKind.TypeLiteral: return decodeReflectionTypeLiteral(some.declaration);
-                    default:
-                        console.log('declarationKindName', getDeclarationKindName(some.declaration.kind));
-                        console.dir(some, { depth: 4 });
-                        throw Error();
-                }
-            case 'tuple':
-                return `[${some.elements.map(getTypeRec).join(', ')}]`;
-            case 'union':
-                return some.types.map(getTypeRec).join(' | ');
-            case 'array':
-                return getTypeRec(some.elementType) + '[]';
-            default:
-                console.log(some);
-                throw Error(some.type);
-        }
-        function decodeReflectionTypeLiteral(ref) {
-            try {
-                if (ref.variant !== 'declaration')
-                    throw Error();
-                if (ref.groups && !ref.signatures) {
-                    if (!Array.isArray(ref.groups))
-                        throw Error();
-                    if (ref.groups.length !== 1)
-                        throw Error();
-                    const [group] = ref.groups;
-                    if (group.title !== 'Properties')
-                        throw Error();
-                    const properties = group.children.map(r => r.escapedName + ':?');
-                    return `{${properties.join(', ')}}`;
-                }
-                if (!ref.groups && ref.signatures) {
-                    if (ref.signatures.length !== 1)
-                        throw Error('ref.signatures.length !== 1');
-                    const [signature] = ref.signatures;
-                    const returnType = signature.type ? getTypeRec(signature.type) : 'void';
-                    const parameters = (signature.parameters ?? [])
-                        .map(p => {
-                        return p.name + (p.type ? ': ' + getTypeRec(p.type) : '');
-                    }).join(', ');
-                    return `(${parameters}) => ${returnType}`;
-                }
-                throw Error();
-            }
-            catch (error) {
-                console.dir(ref, { depth: 3 });
-                throw error;
-            }
-        }
-    }
-}
-function createSourceLink(reference) {
-    if (!reference.sources || reference.sources.length < 1)
-        return null;
-    if (reference.sources.length > 1)
-        throw Error('ref.sources.length > 1');
-    const [source] = reference.sources;
-    return `<sup><a href="${source.url}">[src]</a></sup>`;
-}
-function createAnchorId(reference) {
-    return `${getDeclarationKindName(reference.kind)}_${reference.name}`.toLowerCase();
-}
-//# sourceMappingURL=typedoc.js.map