@eagleoutice/flowr 2.2.15 → 2.2.16

package/documentation/doc-util/doc-dfg.js

@@ -15,6 +15,7 @@ const assert_1 = require("../../util/assert");
 const time_1 = require("../../util/text/time");
 const doc_files_1 = require("./doc-files");
 const doc_code_1 = require("./doc-code");
+const config_1 = require("../../config");
 function printDfGraph(graph, mark, simplified = false) {
     return `
 ${(0, doc_code_1.codeBlock)('mermaid', (0, dfg_1.graphToMermaid)({
@@ -37,7 +38,7 @@ async function printDfGraphForCode(parser, code, { simplified = false, mark, sho
     const now = performance.now();
     const result = await (0, default_pipelines_1.createDataflowPipeline)(parser, {
         request: (0, retriever_1.requestFromInput)(code)
-    }).allRemainingSteps();
+    }, config_1.defaultConfigOptions).allRemainingSteps();
     const duration = performance.now() - now;
     if (switchCodeAndGraph) {
         (0, assert_1.guard)(showCode, 'can not switch code and graph if code is not shown');
@@ -76,7 +77,7 @@ async function verifyExpectedSubgraph(shell, code, expectedSubgraph) {
         parser: shell,
         request: (0, retriever_1.requestFromInput)(code),
         getId: (0, decorate_1.deterministicCountingIdGenerator)(0)
-    }).allRemainingSteps();
+    }, config_1.defaultConfigOptions).allRemainingSteps();
     expectedSubgraph.setIdMap(info.normalize.idMap);
     expectedSubgraph = (0, resolve_graph_1.resolveDataflowGraph)(expectedSubgraph);
     const report = (0, diff_dataflow_graph_1.diffOfDataflowGraphs)({ name: 'expected', graph: expectedSubgraph }, { name: 'got', graph: info.dataflow.graph }, {

package/documentation/doc-util/doc-functions.d.ts

@@ -0,0 +1,24 @@
+import type { Expression } from 'typescript';
+import ts from 'typescript';
+export interface FunctionElementInSource {
+    name: string;
+    node: ts.Node;
+    source: ts.SourceFile;
+    kind: 'function';
+    arguments: Expression[];
+    lineNumber: number;
+    comments?: string[];
+}
+export interface GetFunctionsOption {
+    readonly rootFolder?: string;
+    readonly files?: readonly string[];
+    readonly fname?: RegExp;
+}
+export interface FunctionsReport {
+    info: FunctionElementInSource[];
+    program: ts.Program;
+}
+/**
+ * Inspect typescript source code for types and return a report.
+ */
+export declare function getFunctionsFromFolder(options: GetFunctionsOption): FunctionsReport;

package/documentation/doc-util/doc-functions.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFunctionsFromFolder = getFunctionsFromFolder;
+const typescript_1 = __importDefault(require("typescript"));
+const assert_1 = require("../../util/assert");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const doc_types_1 = require("./doc-types");
+function collectHierarchyInformation(sourceFiles, options, fname) {
+    const hierarchyList = [];
+    const visit = (node, sourceFile) => {
+        if (!node) {
+            return;
+        }
+        if (typescript_1.default.isCallExpression(node) || typescript_1.default.isNewExpression(node)) {
+            const name = node.expression.getText(sourceFile);
+            if (!fname || fname.test(name)) {
+                const comments = typescript_1.default.getLeadingCommentRanges(sourceFile.getText(sourceFile), node.getFullStart())?.map(c => {
+                    return (0, doc_types_1.removeCommentSymbolsFromTypeScriptComment)(sourceFile.getText(sourceFile).substring(c.pos, c.end).trim());
+                });
+                hierarchyList.push({
+                    name: (0, doc_types_1.dropGenericsFromTypeName)(name),
+                    node,
+                    kind: 'function',
+                    comments,
+                    lineNumber: (0, doc_types_1.getStartLineOfTypeScriptNode)(node, sourceFile),
+                    source: sourceFile,
+                    arguments: node.arguments?.map(n => n) ?? []
+                });
+            }
+        }
+        typescript_1.default.forEachChild(node, child => visit(child, sourceFile));
+    };
+    sourceFiles.forEach(sourceFile => {
+        visit(sourceFile, sourceFile);
+    });
+    return hierarchyList;
+}
+/**
+ * Inspect typescript source code for types and return a report.
+ */
+function getFunctionsFromFolder(options) {
+    (0, assert_1.guard)(options.rootFolder !== undefined || options.files !== undefined, 'Either rootFolder or files must be provided');
+    const fileNames = [...options.files ?? []];
+    if (options.rootFolder) {
+        for (const fileBuff of fs_1.default.readdirSync(options.rootFolder, { recursive: true })) {
+            const file = fileBuff.toString();
+            if (file.endsWith('.ts')) {
+                fileNames.push(path_1.default.join(options.rootFolder, file));
+            }
+        }
+    }
+    const { files, program } = (0, doc_types_1.getTypeScriptSourceFiles)(fileNames);
+    (0, assert_1.guard)(files.length > 0, () => `No source files found for ${JSON.stringify(fileNames)}`);
+    const withProgram = { ...options, program };
+    const hierarchyList = collectHierarchyInformation(files, withProgram, options.fname);
+    return {
+        info: hierarchyList,
+        program
+    };
+}
+//# sourceMappingURL=doc-functions.js.map

package/documentation/doc-util/doc-normalized-ast.js

@@ -12,6 +12,7 @@ const assert_1 = require("../../util/assert");
 const ast_1 = require("../../util/mermaid/ast");
 const time_1 = require("../../util/text/time");
 const doc_files_1 = require("./doc-files");
+const config_1 = require("../../config");
 function printNormalizedAst(ast, prefix = 'flowchart TD\n') {
     return `
 \`\`\`mermaid
@@ -23,7 +24,7 @@ async function printNormalizedAstForCode(parser, code, { showCode = true, prefix
     const now = performance.now();
     const result = await (0, default_pipelines_1.createNormalizePipeline)(parser, {
         request: (0, retriever_1.requestFromInput)(code)
-    }).allRemainingSteps();
+    }, config_1.defaultConfigOptions).allRemainingSteps();
     const duration = performance.now() - now;
     const metaInfo = `The analysis required _${(0, time_1.printAsMs)(duration)}_ (including parsing with the [${parser.name}](${doc_files_1.FlowrWikiBaseRef}/Engines) engine) within the generation environment.`;
     return '\n\n' + printNormalizedAst(result.normalize.ast, prefix) + (showCode ? `
@@ -57,7 +58,7 @@ async function verifyExpectedSubgraph(shell, code, expectedSubgraph) {
     const info = await (0, default_pipelines_1.createDataflowPipeline)(shell, {
         request: (0, retriever_1.requestFromInput)(code),
         getId: (0, decorate_1.deterministicCountingIdGenerator)(0)
-    }).allRemainingSteps();
+    }, config_1.defaultConfigOptions).allRemainingSteps();
     expectedSubgraph.setIdMap(info.normalize.idMap);
     expectedSubgraph = (0, resolve_graph_1.resolveDataflowGraph)(expectedSubgraph);
     const report = (0, diff_dataflow_graph_1.diffOfDataflowGraphs)({ name: 'expected', graph: expectedSubgraph }, { name: 'got', graph: info.dataflow.graph }, {

package/documentation/doc-util/doc-print.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Writes the wiki documentation to the specified output path.
+ * Returns true if the file was updated, false if it was unchanged.
+ */
+export declare function writeWikiTo(text: string, output_path: string, check_change?: boolean): boolean;

package/documentation/doc-util/doc-print.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeWikiTo = writeWikiTo;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/* eslint-disable */
+const IgnoreRegex = /[0-9]+(\.[0-9]+)? ?ms|"timing":\s*[0-9]+(\.0-9)?,?|tmp-[A-Za-z0-9-]+/g;
+/* eslint-enable */
+/**
+ * Checks whether the file contains a different content, but ignores timing and some other non-semantic changes.
+ */
+function didFileChange(filePath, content) {
+    if (!fs_1.default.existsSync(filePath)) {
+        return true; // If the file does not exist, it is considered changed.
+    }
+    const currentContent = fs_1.default.readFileSync(filePath, 'utf-8');
+    const cleanedCurrentContent = currentContent.replace(IgnoreRegex, '');
+    const cleanedNewContent = content.replace(IgnoreRegex, '');
+    return cleanedCurrentContent !== cleanedNewContent;
+}
+/**
+ * Writes the wiki documentation to the specified output path.
+ * Returns true if the file was updated, false if it was unchanged.
+ */
+function writeWikiTo(text, output_path, check_change = true) {
+    if (!check_change || didFileChange(output_path, text)) {
+        fs_1.default.mkdirSync(path_1.default.dirname(output_path), { recursive: true });
+        fs_1.default.writeFileSync(output_path, text, 'utf-8');
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=doc-print.js.map

package/documentation/doc-util/doc-query.js

@@ -17,13 +17,14 @@ const doc_dfg_1 = require("./doc-dfg");
 const doc_code_1 = require("./doc-code");
 const time_1 = require("../../util/text/time");
 const query_print_1 = require("../../queries/query-print");
+const config_1 = require("../../config");
 async function showQuery(shell, code, queries, { showCode, collapseResult, collapseQuery, addOutput = () => '' } = {}) {
     const now = performance.now();
     const analysis = await new pipeline_executor_1.PipelineExecutor(default_pipelines_1.DEFAULT_DATAFLOW_PIPELINE, {
         parser: shell,
         request: (0, retriever_1.requestFromInput)(code)
-    }).allRemainingSteps();
-    const results = (0, query_1.executeQueries)({ dataflow: analysis.dataflow, ast: analysis.normalize }, queries);
+    }, config_1.defaultConfigOptions).allRemainingSteps();
+    const results = (0, query_1.executeQueries)({ dataflow: analysis.dataflow, ast: analysis.normalize, config: config_1.defaultConfigOptions }, queries);
     const duration = performance.now() - now;
     const metaInfo = `
 The analysis required _${(0, time_1.printAsMs)(duration)}_ (including parsing and normalization and the query) within the generation environment.

package/documentation/doc-util/doc-repl.js

@@ -11,6 +11,7 @@ const doc_docker_1 = require("./doc-docker");
 const prompt_1 = require("../../cli/repl/prompt");
 const doc_code_1 = require("./doc-code");
 const print_version_1 = require("../../cli/repl/print-version");
+const config_1 = require("../../config");
 function printHelpForScript(script, starredVersion) {
     let base = `| **${(0, doc_cli_option_1.getReplCommand)(script[0], false, starredVersion !== undefined)}** | ${script[1].description}`;
     if (starredVersion) {
@@ -51,7 +52,7 @@ async function documentReplSession(parser, commands, options) {
                 entry.lines.push(msg);
             }
         };
-        await (0, core_1.replProcessAnswer)(collectingOutput, command.command, parser, options?.allowRSessionAccess ?? false);
+        await (0, core_1.replProcessAnswer)(config_1.defaultConfigOptions, collectingOutput, command.command, parser, options?.allowRSessionAccess ?? false);
         collect.push(entry);
     }
     let result = '';

package/documentation/doc-util/doc-search.js

@@ -17,13 +17,14 @@ const flowr_search_executor_1 = require("../../search/flowr-search-executor");
 const flowr_search_printer_1 = require("../../search/flowr-search-printer");
 const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
 const dfg_1 = require("../../util/mermaid/dfg");
+const config_1 = require("../../config");
 async function showSearch(shell, code, search, { collapseResult = true } = {}) {
     const now = performance.now();
     const analysis = await new pipeline_executor_1.PipelineExecutor(default_pipelines_1.DEFAULT_DATAFLOW_PIPELINE, {
         parser: shell,
         request: (0, retriever_1.requestFromInput)(code)
-    }).allRemainingSteps();
-    const result = (0, flowr_search_executor_1.runSearch)(search, analysis);
+    }, config_1.defaultConfigOptions).allRemainingSteps();
+    const result = (0, flowr_search_executor_1.runSearch)(search, { ...analysis, config: config_1.defaultConfigOptions });
     const duration = performance.now() - now;
     const metaInfo = `
 The search required _${(0, time_1.printAsMs)(duration)}_ (including parsing and normalization and the query) within the generation environment.

package/documentation/doc-util/doc-types.d.ts

@@ -10,21 +10,42 @@ export interface TypeElementInSource {
     comments?: string[];
     readonly properties?: string[];
 }
+export declare function getTypeScriptSourceFiles(fileNames: readonly string[]): {
+    files: ts.SourceFile[];
+    program: ts.Program;
+};
+export declare function dropGenericsFromTypeName(type: string): string;
+export declare function removeCommentSymbolsFromTypeScriptComment(comment: string): string;
+export declare function getTextualCommentsFromTypeScript(node: ts.Node): string[];
+export declare function getStartLineOfTypeScriptNode(node: ts.Node, sourceFile: ts.SourceFile): number;
 export declare function getType(node: ts.Node, typeChecker: ts.TypeChecker): string;
 export declare function followTypeReference(type: ts.TypeReferenceNode, sourceFile: ts.SourceFile): string[];
-export declare function getTypePathLink({ filePath, lineNumber }: TypeElementInSource, prefix?: string): string;
+export declare function getTypePathForTypeScript({ filePath }: Pick<TypeElementInSource, 'filePath'>): string;
+export declare function getTypePathLink(elem: Pick<TypeElementInSource, 'filePath' | 'lineNumber'>, prefix?: string): string;
 export interface GetTypesAsMermaidOption {
     readonly rootFolder?: string;
     readonly files?: readonly string[];
-    readonly typeName: string;
+    /** if you request a type name, we will generate a mermaid diagram for that type */
+    readonly typeNameForMermaid?: string;
     readonly inlineTypes?: readonly string[];
 }
-export interface MermaidTypeReport {
-    text: string;
+export interface TypeReport {
+    /** if you request a type name this will include the mermaid diagram for the type */
+    mermaid: string | undefined;
     info: TypeElementInSource[];
     program: ts.Program;
 }
-export declare function getTypesFromFolderAsMermaid(options: GetTypesAsMermaidOption): MermaidTypeReport;
+export declare function getTypesFromFolder(options: GetTypesAsMermaidOption & {
+    typeNameForMermaid: string;
+}): (TypeReport & {
+    mermaid: string;
+});
+export declare function getTypesFromFolder(options: GetTypesAsMermaidOption & {
+    typeNameForMermaid?: undefined;
+}): (TypeReport & {
+    mermaid: undefined;
+});
+export declare function getTypesFromFolder(options: GetTypesAsMermaidOption): TypeReport;
 export declare function implSnippet(node: TypeElementInSource | undefined, program: ts.Program, showName?: boolean, nesting?: number, open?: boolean): string;
 export interface PrintHierarchyArguments {
     readonly program: ts.Program;
@@ -51,5 +72,6 @@ export declare function printCodeOfElement({ program, info }: FnInfo, name: stri
  * @param realNameWrapper - How to highlight the function in name in the `x::y` format?
  */
 export declare function shortLink(name: string, hierarchy: readonly TypeElementInSource[], codeStyle?: boolean, realNameWrapper?: string): string;
-export declare function getDocumentationForType(name: string, hierarchy: TypeElementInSource[], prefix?: string): string;
+export declare function shortLinkFile(name: string, hierarchy: readonly TypeElementInSource[]): string;
+export declare function getDocumentationForType(name: string, hierarchy: TypeElementInSource[], prefix?: string, fuzzy?: boolean): string;
 export {};

package/documentation/doc-util/doc-types.js

@@ -4,14 +4,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mermaidHide = void 0;
+exports.getTypeScriptSourceFiles = getTypeScriptSourceFiles;
+exports.dropGenericsFromTypeName = dropGenericsFromTypeName;
+exports.removeCommentSymbolsFromTypeScriptComment = removeCommentSymbolsFromTypeScriptComment;
+exports.getTextualCommentsFromTypeScript = getTextualCommentsFromTypeScript;
+exports.getStartLineOfTypeScriptNode = getStartLineOfTypeScriptNode;
 exports.getType = getType;
 exports.followTypeReference = followTypeReference;
+exports.getTypePathForTypeScript = getTypePathForTypeScript;
 exports.getTypePathLink = getTypePathLink;
-exports.getTypesFromFolderAsMermaid = getTypesFromFolderAsMermaid;
+exports.getTypesFromFolder = getTypesFromFolder;
 exports.implSnippet = implSnippet;
 exports.printHierarchy = printHierarchy;
 exports.printCodeOfElement = printCodeOfElement;
 exports.shortLink = shortLink;
+exports.shortLinkFile = shortLinkFile;
 exports.getDocumentationForType = getDocumentationForType;
 const typescript_1 = __importDefault(require("typescript"));
 const assert_1 = require("../../util/assert");
@@ -23,7 +30,7 @@ const doc_code_1 = require("./doc-code");
 const doc_structure_1 = require("./doc-structure");
 const html_hover_over_1 = require("../../util/html-hover-over");
 const doc_general_1 = require("./doc-general");
-function getSourceFiles(fileNames) {
+function getTypeScriptSourceFiles(fileNames) {
     try {
         const program = typescript_1.default.createProgram(fileNames, { target: typescript_1.default.ScriptTarget.ESNext });
         return { program, files: fileNames.map(fileName => program.getSourceFile(fileName)).filter(file => !!file) };
@@ -33,7 +40,7 @@ function getSourceFiles(fileNames) {
         return { files: [], program: undefined };
     }
 }
-function dropGenericsFromType(type) {
+function dropGenericsFromTypeName(type) {
     let previous;
     do {
         previous = type;
@@ -41,7 +48,7 @@ function dropGenericsFromType(type) {
     } while (type !== previous);
     return type;
 }
-function removeCommentSymbols(comment) {
+function removeCommentSymbolsFromTypeScriptComment(comment) {
     return comment
         // remove '/** \n * \n */...
         .replace(/^\/\*\*?/gm, '').replace(/^\s*\*\s*/gm, '').replace(/\*\/$/gm, '').replace(/^\s*\*/gm, '')
@@ -49,22 +56,22 @@ function removeCommentSymbols(comment) {
         .replace(/\{@[a-zA-Z]+ ([^}]+\|)?(?<name>[^}]+)}/gm, '<code>$<name></code>')
         .trim();
 }
-function getTextualComments(node) {
+function getTextualCommentsFromTypeScript(node) {
     const comments = typescript_1.default.getJSDocCommentsAndTags(node);
     const out = [];
     for (const { comment } of comments) {
         if (typeof comment === 'string') {
-            out.push(removeCommentSymbols(comment));
+            out.push(removeCommentSymbolsFromTypeScriptComment(comment));
         }
         else if (comment !== undefined) {
             for (const c of comment) {
-                out.push(removeCommentSymbols(c.getText(c.getSourceFile())));
+                out.push(removeCommentSymbolsFromTypeScriptComment(c.getText(c.getSourceFile())));
             }
         }
     }
     return out;
 }
-function getStartLine(node, sourceFile) {
+function getStartLineOfTypeScriptNode(node, sourceFile) {
     const lineStart = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line;
     return lineStart + 1;
 }
@@ -97,17 +104,17 @@ function collectHierarchyInformation(sourceFiles, options) {
             const interfaceName = node.name?.getText(sourceFile) ?? '';
             const baseTypes = node.heritageClauses?.flatMap(clause => clause.types
                 .map(type => type.getText(sourceFile) ?? '')
-                .map(dropGenericsFromType)) ?? [];
+                .map(dropGenericsFromTypeName)) ?? [];
             const generics = node.typeParameters?.map(param => param.getText(sourceFile) ?? '') || [];
             hierarchyList.push({
-                name: dropGenericsFromType(interfaceName),
+                name: dropGenericsFromTypeName(interfaceName),
                 node,
                 kind: 'interface',
                 extends: baseTypes,
                 generics,
-                comments: getTextualComments(node),
+                comments: getTextualCommentsFromTypeScript(node),
                 filePath: sourceFile.fileName,
-                lineNumber: getStartLine(node, sourceFile),
+                lineNumber: getStartLineOfTypeScriptNode(node, sourceFile),
                 properties: node.members.map(member => {
                     const name = member.name?.getText(sourceFile) ?? '';
                     return `${name}${(0, mermaid_1.escapeMarkdown)(': ' + getType(member, typeChecker))}`;
@@ -121,55 +128,69 @@ function collectHierarchyInformation(sourceFiles, options) {
                 baseTypes = node.type.types
                     .filter(typeNode => typescript_1.default.isTypeReferenceNode(typeNode))
                     .flatMap(typeName => followTypeReference(typeName, sourceFile))
-                    .map(dropGenericsFromType);
+                    .map(dropGenericsFromTypeName);
             }
             else if (typescript_1.default.isTypeReferenceNode(node.type)) {
-                baseTypes = [...followTypeReference(node.type, sourceFile)].map(dropGenericsFromType);
+                baseTypes = [...followTypeReference(node.type, sourceFile)].map(dropGenericsFromTypeName);
             }
             const generics = node.typeParameters?.map(param => param.getText(sourceFile) ?? '') ?? [];
             hierarchyList.push({
-                name: dropGenericsFromType(typeName),
+                name: dropGenericsFromTypeName(typeName),
                 node,
                 kind: 'type',
                 extends: baseTypes,
-                comments: getTextualComments(node),
+                comments: getTextualCommentsFromTypeScript(node),
                 generics,
                 filePath: sourceFile.fileName,
-                lineNumber: getStartLine(node, sourceFile),
+                lineNumber: getStartLineOfTypeScriptNode(node, sourceFile),
             });
         }
         else if (typescript_1.default.isEnumDeclaration(node)) {
             const enumName = node.name?.getText(sourceFile) ?? '';
             hierarchyList.push({
-                name: dropGenericsFromType(enumName),
+                name: dropGenericsFromTypeName(enumName),
                 node,
                 kind: 'enum',
                 extends: [],
-                comments: getTextualComments(node),
+                comments: getTextualCommentsFromTypeScript(node),
                 generics: [],
                 filePath: sourceFile.fileName,
-                lineNumber: getStartLine(node, sourceFile),
+                lineNumber: getStartLineOfTypeScriptNode(node, sourceFile),
                 properties: node.members.map(member => {
                     const name = member.name?.getText(sourceFile) ?? '';
                     return `${name}${(0, mermaid_1.escapeMarkdown)(': ' + getType(member, typeChecker))}`;
                 })
             });
         }
+        else if (typescript_1.default.isEnumMember(node)) {
+            const typeName = node.parent.name?.getText(sourceFile) ?? '';
+            const enumName = dropGenericsFromTypeName(typeName);
+            hierarchyList.push({
+                name: dropGenericsFromTypeName(node.name.getText(sourceFile)),
+                node,
+                kind: 'enum',
+                extends: [enumName],
+                comments: getTextualCommentsFromTypeScript(node),
+                generics: [],
+                filePath: sourceFile.fileName,
+                lineNumber: getStartLineOfTypeScriptNode(node, sourceFile),
+            });
+        }
         else if (typescript_1.default.isClassDeclaration(node)) {
             const className = node.name?.getText(sourceFile) ?? '';
             const baseTypes = node.heritageClauses?.flatMap(clause => clause.types
                 .map(type => type.getText(sourceFile) ?? '')
-                .map(dropGenericsFromType)) ?? [];
+                .map(dropGenericsFromTypeName)) ?? [];
             const generics = node.typeParameters?.map(param => param.getText(sourceFile) ?? '') ?? [];
             hierarchyList.push({
-                name: dropGenericsFromType(className),
+                name: dropGenericsFromTypeName(className),
                 node,
                 kind: 'class',
                 extends: baseTypes,
-                comments: getTextualComments(node),
+                comments: getTextualCommentsFromTypeScript(node),
                 generics,
                 filePath: sourceFile.fileName,
-                lineNumber: getStartLine(node, sourceFile),
+                lineNumber: getStartLineOfTypeScriptNode(node, sourceFile),
                 properties: node.members.map(member => {
                     const name = member.name?.getText(sourceFile) ?? '';
                     return `${name}${(0, mermaid_1.escapeMarkdown)(': ' + getType(member, typeChecker))}`;
@@ -178,16 +199,16 @@ function collectHierarchyInformation(sourceFiles, options) {
         }
         else if (typescript_1.default.isVariableDeclaration(node) || typescript_1.default.isExportDeclaration(node) || typescript_1.default.isExportAssignment(node) || typescript_1.default.isDeclarationStatement(node)) {
             const name = node.name?.getText(sourceFile) ?? '';
-            const comments = getTextualComments(node);
+            const comments = getTextualCommentsFromTypeScript(node);
             hierarchyList.push({
-                name: dropGenericsFromType(name),
+                name: dropGenericsFromTypeName(name),
                 node,
                 kind: 'variable',
                 extends: [],
                 comments,
                 generics: [],
                 filePath: sourceFile.fileName,
-                lineNumber: getStartLine(node, sourceFile),
+                lineNumber: getStartLineOfTypeScriptNode(node, sourceFile),
             });
         }
         else if (typescript_1.default.isPropertyAssignment(node) || typescript_1.default.isPropertyDeclaration(node) || typescript_1.default.isPropertySignature(node)
@@ -199,16 +220,16 @@ function collectHierarchyInformation(sourceFiles, options) {
                 parent = parent.parent;
             }
             if (typeof parent === 'object' && 'name' in parent) {
-                const comments = getTextualComments(node);
+                const comments = getTextualCommentsFromTypeScript(node);
                 hierarchyList.push({
-                    name: dropGenericsFromType(name),
+                    name: dropGenericsFromTypeName(name),
                     node,
                     kind: 'variable',
                     extends: [parent.name?.getText(sourceFile) ?? ''],
                     comments,
                     generics: [],
                     filePath: sourceFile.fileName,
-                    lineNumber: getStartLine(node, sourceFile),
+                    lineNumber: getStartLineOfTypeScriptNode(node, sourceFile),
                 });
             }
         }
@@ -219,9 +240,12 @@ function collectHierarchyInformation(sourceFiles, options) {
     });
     return hierarchyList;
 }
-function getTypePathLink({ filePath, lineNumber }, prefix = doc_files_1.RemoteFlowrFilePathBaseRef) {
-    const fromSource = filePath.replace(/^.*\/src\//, 'src/').replace(/^.*\/test\//, 'test/');
-    return `${prefix}/${fromSource}#L${lineNumber}`;
+function getTypePathForTypeScript({ filePath }) {
+    return filePath.replace(/^.*\/src\//, 'src/').replace(/^.*\/test\//, 'test/');
+}
+function getTypePathLink(elem, prefix = doc_files_1.RemoteFlowrFilePathBaseRef) {
+    const fromSource = getTypePathForTypeScript(elem);
+    return `${prefix}/${fromSource}#L${elem.lineNumber}`;
 }
 function generateMermaidClassDiagram(hierarchyList, rootName, options, visited = new Set()) {
     const collect = { nodeLines: [], edgeLines: [] };
@@ -261,10 +285,10 @@ function generateMermaidClassDiagram(hierarchyList, rootName, options, visited =
             }
             else {
                 if (node.kind === 'type' || hierarchyList.find(h => h.name === baseType)?.kind === 'type') {
-                    collect.edgeLines.push(`${dropGenericsFromType(baseType)} .. ${node.name}`);
+                    collect.edgeLines.push(`${dropGenericsFromTypeName(baseType)} .. ${node.name}`);
                 }
                 else {
-                    collect.edgeLines.push(`${dropGenericsFromType(baseType)} <|-- ${node.name}`);
+                    collect.edgeLines.push(`${dropGenericsFromTypeName(baseType)} <|-- ${node.name}`);
                 }
                 const { nodeLines, edgeLines } = generateMermaidClassDiagram(hierarchyList, baseType, options, visited);
                 collect.nodeLines.push(...nodeLines);
@@ -275,7 +299,10 @@ function generateMermaidClassDiagram(hierarchyList, rootName, options, visited =
     return collect;
 }
 function visualizeMermaidClassDiagram(hierarchyList, options) {
-    const { nodeLines, edgeLines } = generateMermaidClassDiagram(hierarchyList, options.typeName, options);
+    if (!options.typeNameForMermaid) {
+        return undefined;
+    }
+    const { nodeLines, edgeLines } = generateMermaidClassDiagram(hierarchyList, options.typeNameForMermaid, options);
     return nodeLines.length === 0 && edgeLines.length === 0 ? '' : `
 classDiagram
 direction RL
@@ -284,17 +311,20 @@ ${edgeLines.join('\n')}
 `;
 }
 function getTypesFromFileAsMermaid(fileNames, options) {
-    const { files, program } = getSourceFiles(fileNames);
+    const { files, program } = getTypeScriptSourceFiles(fileNames);
     (0, assert_1.guard)(files.length > 0, () => `No source files found for ${JSON.stringify(fileNames)}`);
     const withProgram = { ...options, program };
     const hierarchyList = collectHierarchyInformation(files, withProgram);
     return {
-        text: visualizeMermaidClassDiagram(hierarchyList, withProgram),
+        mermaid: visualizeMermaidClassDiagram(hierarchyList, withProgram),
         info: hierarchyList,
         program
     };
 }
-function getTypesFromFolderAsMermaid(options) {
+/**
+ * Inspect typescript source code for types and return a report.
+ */
+function getTypesFromFolder(options) {
     (0, assert_1.guard)(options.rootFolder !== undefined || options.files !== undefined, 'Either rootFolder or files must be provided');
     const files = [...options.files ?? []];
     if (options.rootFolder) {
@@ -356,17 +386,22 @@ function printCodeOfElement({ program, info }, name) {
     const code = node.node.getFullText(program.getSourceFile(node.node.getSourceFile().fileName));
     return `${(0, doc_code_1.codeBlock)('ts', code)}\n<i>Defined at <a href="${getTypePathLink(node)}">${getTypePathLink(node, '.')}</a></i>\n`;
 }
-function retrieveNode(name, hierarchy) {
+function fuzzyCompare(a, b) {
+    const aStr = a.toLowerCase().replace(/[^a-z0-9]/g, '-').trim();
+    const bStr = b.toLowerCase().replace(/[^a-z0-9]/g, '-').trim();
+    return aStr === bStr || aStr.includes(bStr) || bStr.includes(aStr);
+}
+function retrieveNode(name, hierarchy, fuzzy = false) {
     let container = undefined;
     if (name.includes('::')) {
         [container, name] = name.split(/:::?/);
     }
-    let node = hierarchy.filter(e => e.name === name);
+    let node = hierarchy.filter(e => fuzzy ? fuzzyCompare(e.name, name) : e.name === name);
     if (node.length === 0) {
         return undefined;
     }
     else if (container) {
-        node = node.filter(n => n.extends.includes(container));
+        node = node.filter(n => fuzzy ? n.extends.some(n => fuzzyCompare(n, container)) : n.extends.includes(container));
         if (node.length === 0) {
             return undefined;
         }
@@ -393,11 +428,20 @@ function shortLink(name, hierarchy, codeStyle = true, realNameWrapper = 'b') {
         pkg = undefined;
     }
     const comments = node.comments?.join('\n').replace(/\\?\n|```[a-zA-Z]*|\s\s*/g, ' ').replace(/<\/?code>|`/g, '').replace(/<\/?p\/?>/g, ' ').replace(/"/g, '\'') ?? '';
-    return `[${codeStyle ? '<code>' : ''}${(node.comments?.length ?? 0) > 0 ?
-        (0, html_hover_over_1.textWithTooltip)(pkg ? `${pkg}::<${realNameWrapper}>${mainName}</${realNameWrapper}>` : mainName, comments.length > 400 ? comments.slice(0, 400) + '...' : comments) : node.name}${codeStyle ? '</code>' : ''}](${getTypePathLink(node)})`;
+    return `<a href="${getTypePathLink(node)}">${codeStyle ? '<code>' : ''}${(node.comments?.length ?? 0) > 0 ?
+        (0, html_hover_over_1.textWithTooltip)(pkg ? `${pkg}::<${realNameWrapper}>${mainName}</${realNameWrapper}>` : mainName, comments.length > 400 ? comments.slice(0, 400) + '...' : comments) : node.name}${codeStyle ? '</code>' : ''}</a>`;
 }
-function getDocumentationForType(name, hierarchy, prefix = '') {
+function shortLinkFile(name, hierarchy) {
     const res = retrieveNode(name, hierarchy);
+    if (!res) {
+        console.error(`Could not find node ${name} when resolving short link!`);
+        return '';
+    }
+    const [, , node] = res;
+    return `<a href="${getTypePathLink(node)}">${getTypePathForTypeScript(node)}</a>`;
+}
+function getDocumentationForType(name, hierarchy, prefix = '', fuzzy = false) {
+    const res = retrieveNode(name, hierarchy, fuzzy);
     if (!res) {
         return '';
     }