@iviva/react-tsdoc 0.1.8 → 0.2.1

package/dist/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -14,628 +18,137 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.main = void 0;
-const tsdoc = __importStar(require("@microsoft/tsdoc"));
-const fs = __importStar(require("fs"));
+exports.generateTypeDefinition = exports.generateDocs = exports.load = void 0;
 const ts = __importStar(require("typescript"));
-const chalk_1 = __importDefault(require("chalk"));
-const clap_1 = __importDefault(require("clap"));
-const mkdirp_1 = __importDefault(require("mkdirp"));
-var ComponentFlags;
-(function (ComponentFlags) {
-    ComponentFlags[ComponentFlags["None"] = 0] = "None";
-    ComponentFlags[ComponentFlags["Export"] = 1] = "Export";
-    ComponentFlags[ComponentFlags["Hook"] = 2] = "Hook";
-})(ComponentFlags || (ComponentFlags = {}));
-function logCompilerMessage(message) {
-    console.error(chalk_1.default.gray(`[TypeScript] ${message}`));
-}
-function logDebug(...objects) {
-    console.log(chalk_1.default.gray(...objects));
-}
-function logInfo(...objects) {
-    console.log(chalk_1.default.green(...objects));
-}
-function logWarning(...objects) {
-    console.log(chalk_1.default.redBright(...objects));
-}
-function logError(...objects) {
-    console.log(chalk_1.default.redBright(...objects));
-}
-function indentCode(code, chars) {
-    let lines = code.split('\n').map(line => line.trimRight());
-    return lines.map(line => chars + line).join('\n');
-}
-class MarkdownBuilder {
-    constructor() {
-        this.code = "";
-    }
-    addTitle(title, level) {
-        let headerChar = '#';
-        let prefix = '';
-        for (let i = 0; i < level; i++) {
-            prefix += headerChar;
-        }
-        this.code += prefix + ' ' + title + '\n\n';
-    }
-    addParagraph(p) {
-        this.code += '\n\n' + p + '\n\n';
-    }
-    addCode(code) {
-        code = code.trim();
-        if (code.startsWith('```')) {
-            code = code.substring(3);
-        }
-        if (code.endsWith('```')) {
-            code = code.substring(0, code.length - 3);
-        }
-        this.code += '\n\n```tsx\n' + code.trim() + '\n```\n\n';
-    }
-    addTable(table) {
-        const tableFormat = (s) => {
-            return s.replace(/\s+/g, ' ').replace(/\|/g, '\\|');
-        };
-        if (table.length == 0) {
-            this.code += '\n\n';
-            return;
-        }
-        let headers = Object.keys(table[0]);
-        this.code += '|' + (headers.map(tableFormat)).join('|') + '|\n';
-        this.code += '|' + (headers.map(h => '-')).join('|') + '|\n';
-        for (let i in table) {
-            let row = table[i];
-            this.code += '|' + (headers.map(h => tableFormat(row[h]))).join('|') + '|\n';
-        }
-        this.code += '\n\n';
-    }
-    toString() {
-        return this.code;
-    }
-}
-function extractActualContentFromDocMess(node) {
-    if (!node) {
-        return "";
-    }
-    let result = "";
-    if (node instanceof tsdoc.DocExcerpt) {
-        result += node.content.toString();
-    }
-    for (const childNode of node.getChildNodes()) {
-        result += extractActualContentFromDocMess(childNode);
-    }
-    return result;
-}
-function parseTSDocComment(comment) {
-    let config = new tsdoc.TSDocConfiguration();
-    config.addTagDefinition(new tsdoc.TSDocTagDefinition({
-        tagName: '@export',
-        syntaxKind: tsdoc.TSDocTagSyntaxKind.ModifierTag,
-        allowMultiple: false
-    }));
-    config.addTagDefinition(new tsdoc.TSDocTagDefinition({
-        tagName: '@hook',
-        syntaxKind: tsdoc.TSDocTagSyntaxKind.ModifierTag,
-        allowMultiple: false
-    }));
-    let parser = new tsdoc.TSDocParser(config);
-    let ctx = parser.parseString(comment);
-    let summary = extractActualContentFromDocMess(ctx.docComment.summarySection);
-    let examples = [];
-    let props = ComponentFlags.None;
-    for (const block of ctx.docComment.customBlocks) {
-        if (block.blockTag.tagName == '@example') {
-            let example = { summary: extractActualContentFromDocMess(block.content) };
-            examples.push(example);
-        }
-    }
-    let flags = ComponentFlags.None;
-    if (ctx.docComment.modifierTagSet.hasTagName('@export')) {
-        flags = flags | ComponentFlags.Export;
-    }
-    if (ctx.docComment.modifierTagSet.hasTagName('@hook')) {
-        flags = flags | ComponentFlags.Hook;
-    }
-    return [summary, examples, flags];
-}
-function generatePropDocs(inf) {
-    let results = [];
-    for (let i in inf.members) {
-        let prop = inf.members[i];
-        let propDoc = { examples: [], name: prop.name, summary: '', type: prop.type };
-        [propDoc.summary, propDoc.examples] = parseTSDocComment(prop.comment);
-        results.push(propDoc);
-    }
-    return results;
-}
-function generateHookTypeDefinition(hook) {
-    return `export const ${hook.name}:${hook.type};`;
-}
-function generateComponentTypeDefinition(c, interfaces) {
-    let code = "";
-    let type = c.type || 'functional';
-    let inf = interfaces[c.propType];
-    if (inf) {
-        code += inf.comment + '\n';
-        code += inf.code + '\n';
-    }
-    if (c.stateType) {
-        let stateInf = interfaces[c.stateType];
-        if (stateInf) {
-            code += stateInf.comment + '\n';
-            code += stateInf.code + '\n';
-        }
-    }
-    if (c.refType) {
-        let refInf = interfaces[c.refType];
-        if (refInf) {
-            code += refInf.comment + '\n';
-            code += refInf.code + '\n';
-        }
-    }
-    code += c.comment + '\n';
-    switch (type) {
-        case 'functional':
-            code += `export const ${c.name} : React.FunctionComponent<${c.propType}>;\n`;
-            break;
-        case 'class':
-            code += `export class ${c.name} extends React.Component<${c.propType}, ${c.stateType || 'any'}> {}\n`;
-            break;
-        case 'forwardRef':
-            code += `export const ${c.name}:React.ForwardRefExoticComponent<${c.propType} & React.RefAttributes<${c.refType || 'any'}>>;\n`;
-            break;
-    }
-    return code;
-}
-function fillRelatedTypes(t, types, docInfo) {
-    if (docInfo.interfaces[t]) {
-        types[t] = 1;
-        let inf = docInfo.interfaces[t];
-        for (let m of inf.members) {
-            fillRelatedTypes(m.comment, types, docInfo);
-        }
-        return;
-    }
-    if (docInfo.unions[t]) {
-        types[t] = 1;
-        return;
-    }
-    if (docInfo.functions[t]) {
-        let f = docInfo.functions[t];
-        types[t] = 1;
-        fillRelatedTypes(f.return, types, docInfo);
-        for (let p of f.parameters) {
-            let pt = p.type;
-            fillRelatedTypes(pt, types, docInfo);
-        }
-    }
-}
-function generateDocObject(docInfo) {
-    let components = [];
-    //let typesToExport:any = {};
-    for (let cn in docInfo.components) {
-        let componentDoc = { examples: [], name: cn, props: [], summary: '', flags: ComponentFlags.None };
-        let componentInfo = docInfo.components[cn];
-        [componentDoc.summary, componentDoc.examples, componentDoc.flags] = parseTSDocComment(componentInfo.comment);
-        let propType = docInfo.interfaces[componentInfo.propType];
-        if (!!propType) {
-            componentDoc.props = generatePropDocs(propType);
-        }
-        //typesToExport[componentInfo.propType] = 1;
-        components.push(componentDoc);
-    }
-    let hooks = [];
-    for (let hi in docInfo.hooks) {
-        let hook = docInfo.hooks[hi];
-        let hookDoc = { name: hook.name, flags: ComponentFlags.None, summary: '', examples: [] };
-        [hookDoc.summary, hookDoc.examples, hookDoc.flags] = parseTSDocComment(hook.comment);
-        let propType = docInfo.functions[hook.type];
-        // if (!!propType) {
-        //     typesToExport[hook.type] = 1;
-        // }
-        hooks.push(hookDoc);
-    }
-    //console.log(typesToExport);
-    // for(let k of Object.keys(typesToExport)) {
-    //     fillRelatedTypes(k,typesToExport,docInfo);
-    // }
-    let types = [];
-    for (let k of Object.keys(docInfo.interfaces)) {
-        let inf = docInfo.interfaces[k];
-        let typeDoc = { examples: [], name: inf.name, summary: '', type: 'interface', code: '', flags: ComponentFlags.None };
-        typeDoc.code = inf.code;
-        [typeDoc.summary, typeDoc.examples, typeDoc.flags] = parseTSDocComment(inf.comment);
-        types.push(typeDoc);
-    }
-    for (let k of Object.keys(docInfo.functions)) {
-        let inf = docInfo.functions[k];
-        let typeDoc = { examples: [], name: k, summary: '', type: 'function', code: '', flags: ComponentFlags.None };
-        typeDoc.code = inf.code;
-        [typeDoc.summary, typeDoc.examples, typeDoc.flags] = parseTSDocComment(inf.comment);
-        types.push(typeDoc);
-    }
-    for (let k of Object.keys(docInfo.unions)) {
-        let inf = docInfo.unions[k];
-        let typeDoc = { examples: [], name: k, summary: '', type: 'union', code: '', flags: ComponentFlags.None };
-        typeDoc.code = inf.code;
-        [typeDoc.summary, typeDoc.examples, typeDoc.flags] = parseTSDocComment(inf.comment);
-        types.push(typeDoc);
-    }
-    return { components, hooks, types };
-}
-function extractComment(node) {
-    let fullText = node.getSourceFile().getFullText();
-    let comments = ts.getLeadingCommentRanges(fullText, node.pos);
-    if (!comments)
-        return '';
-    return comments.map(c => fullText.slice(c.pos, c.end)).join('\n');
-}
-function getCode(node) {
-    return node.getSourceFile().getFullText().substring(node.getStart(), node.getEnd());
-}
-function parseFunctionSignature(node, docInfo) {
-}
-function parseInterfaceDeclaration(node, docInfo) {
-    let name = node.name.getText();
-    let members = node.members;
-    if (members.length == 1 && members[0].kind == ts.SyntaxKind.CallSignature) {
-        return parseFunctionSignature(members[0], docInfo);
-    }
-    let docs = extractComment(node);
-    let inf = { comment: docs, members: [], name: name, code: getCode(node) };
-    for (let i = 0; i < members.length; i++) {
-        let member = members[i];
-        let name = member.name.getText();
-        let type = member.type.getText();
-        let mdoc = extractComment(member);
-        inf.members.push({ comment: mdoc, name: name, type: type });
-    }
-    docInfo.interfaces[name] = inf;
-}
-function parseVariableDeclaration(node, docInfo) {
-    var _a, _b, _c, _d, _e, _f;
-    let type = (_b = (_a = node.type) === null || _a === void 0 ? void 0 : _a.typeName) === null || _b === void 0 ? void 0 : _b.getText();
-    if (((_d = (_c = node) === null || _c === void 0 ? void 0 : _c.type) === null || _d === void 0 ? void 0 : _d.kind) == ts.SyntaxKind.CallSignature ||
-        ((_f = (_e = node) === null || _e === void 0 ? void 0 : _e.type) === null || _f === void 0 ? void 0 : _f.kind) == ts.SyntaxKind.FunctionType) {
-        console.log('dug');
-    }
-    if (!type) {
-        return;
-    }
-    let name = node.name.getText();
-    if (type == 'React.FunctionComponent') {
-        let propType = node.type.typeArguments[0].getText();
-        let comment = extractComment(node.parent);
-        docInfo.components[name] = { comment, propType, name, type: 'functional' };
-        return;
-    }
-    if (type == 'React.ForwardRefExoticComponent') {
-        let cType = node.type.typeArguments[0].getText();
-        // get prop type and ref type 
-        // assume 
-        //  - props defined as following format  <PropType & RefType>
-        //  - RefType always starts with `React.RefAttributes`
-        let parts = cType.split("&", 2).map(p => p.trim());
-        let propType = parts[0];
-        let refType = parts[1];
-        if (parts[0].startsWith('React.RefAttributes')) {
-            propType = parts[1];
-            refType = parts[0];
-        }
-        refType = refType
-            .replace('React.RefAttributes<', '')
-            .replace(">", '')
-            .trim();
-        let comment = extractComment(node.parent);
-        docInfo.components[name] = { comment, propType, refType, name, type: 'forwardRef' };
-        return;
-    }
-    if (name.startsWith('use')) {
-        let comment = extractComment(node.parent);
-        let parameters = [];
-        docInfo.hooks[name] = { name, type, parameters, comment };
-    }
-}
-function parseClassDeclaration(node, docInfo) {
-    var _a, _b;
-    let className = (_b = (_a = node) === null || _a === void 0 ? void 0 : _a.heritageClauses[0]) === null || _b === void 0 ? void 0 : _b.types[0].expression.getText();
-    if (className == 'React.Component') {
-        let propType = node.heritageClauses[0].types[0].typeArguments[0].getText();
-        let stateType = node.heritageClauses[0].types[0].typeArguments[1].getText();
-        let comment = extractComment(node);
-        let name = node.name.getText();
-        docInfo.components[name] = { comment, propType, name, stateType, type: 'class' };
-    }
-}
-function parseTypeAlias(node, docInfo) {
-    let name = node.name.getText();
-    let type = node.type;
-    if (type.kind == ts.SyntaxKind.FunctionType) {
-        let returnType = type.getText();
-        let parameters = type.parameters;
-        let comment = extractComment(node);
-        let code = getCode(node);
-        let f = { parameters: [], return: returnType, comment, code };
-        for (let p = 0; p < parameters.length; p++) {
-            let parameter = parameters[p];
-            let fp = { name: parameter.name.getText(), type: parameter.type.getText() };
-            f.parameters.push(fp);
-        }
-        docInfo.functions[name] = f;
-        return;
-    }
-    if (type.kind == ts.SyntaxKind.UnionType) {
-        let types = type.types;
-        let comment = extractComment(node);
-        let code = getCode(node);
-        let u = { items: [], comment, code };
-        for (let p = 0; p < types.length; p++) {
-            let txt = types[p].getText();
-            u.items.push(txt);
-        }
-        docInfo.unions[name] = u;
-    }
-}
-function walkTree(node, docInfo) {
-    switch (node.kind) {
-        case ts.SyntaxKind.TypeAliasDeclaration:
-            parseTypeAlias(node, docInfo);
-            break;
-        case ts.SyntaxKind.InterfaceDeclaration:
-            parseInterfaceDeclaration(node, docInfo);
-            break;
-        case ts.SyntaxKind.VariableDeclaration:
-            parseVariableDeclaration(node, docInfo);
-            break;
-        case ts.SyntaxKind.ClassDeclaration:
-            parseClassDeclaration(node, docInfo);
-            break;
-        case ts.SyntaxKind.FunctionDeclaration:
-        case 242:
-            parseVariableDeclaration(node, docInfo);
-            break;
-    }
-    node.forEachChild((child) => walkTree(child, docInfo));
-}
-function validateProgram(program) {
-    const compilerDiagnostics = program.getSemanticDiagnostics();
-    if (compilerDiagnostics.length > 0) {
-        for (const diagnostic of compilerDiagnostics) {
-            const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
-            if (diagnostic.file) {
-                const location = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-                const formattedMessage = `${diagnostic.file.fileName}(${location.line + 1},${location.character + 1}):`
-                    + `${message}`;
-                logCompilerMessage(formattedMessage);
-            }
-            else {
-                logCompilerMessage(message);
-            }
-        }
-    }
-    else {
-        logCompilerMessage('No compiler errors or warnings.');
-    }
-}
-function getSources(program) {
-    return program.getSourceFiles().filter(f => {
-        return f.fileName.indexOf('node_modules') < 0;
-    }).map(f => f.fileName);
-}
-function generateExportModule(docs, docInfo, options) {
-    let code = '';
-    if (options === null || options === void 0 ? void 0 : options.moduleName) {
-        code += `declare module "${options.moduleName}" {\n`;
-    }
-    for (let i in docs.types) {
-        let obj = docs.types[i];
-        let comment = '';
-        if (docInfo.interfaces[obj.name]) {
-            comment = docInfo.interfaces[obj.name].comment;
-        }
-        if (docInfo.functions[obj.name]) {
-            comment = docInfo.functions[obj.name].comment;
-        }
-        if (docInfo.unions[obj.name]) {
-            comment = docInfo.unions[obj.name].comment;
-        }
-        if (ComponentFlags.Export === (obj.flags & ComponentFlags.Export)) {
-            code += indentCode('\n' + comment + '\n' + 'export ' + obj.code + '\n', '    ');
-        }
-    }
-    for (let i in docs.components) {
-        let doc = docs.components[i];
-        if (ComponentFlags.Export === (doc.flags & ComponentFlags.Export)) {
-            let component = docInfo.components[doc.name];
-            let componentCode = generateComponentTypeDefinition(component, docInfo.interfaces);
-            code += indentCode(componentCode, '    ');
-        }
-    }
-    for (let i in docs.hooks) {
-        let doc = docs.hooks[i];
-        if (ComponentFlags.Export === (doc.flags & ComponentFlags.Export)) {
-            let hook = docInfo.hooks[doc.name];
-            let hookCode = generateHookTypeDefinition(hook);
-            code += indentCode(hookCode, '    ');
-        }
-    }
-    code += "\n}\n";
-    return code;
-}
+const analyzer_1 = require("./core/analyzer");
+const component_1 = require("./generators/docs/component");
+const hook_1 = require("./generators/docs/hook");
+const type_1 = require("./generators/docs/type");
+const function_1 = require("./generators/docs/function");
+const module_1 = require("./generators/types/module");
+const file_1 = require("./utils/file");
+const logger_1 = require("./utils/logger");
+const type_helpers_1 = require("./utils/type-helpers");
 function load(root) {
-    let options = {
+    const options = {
         jsx: ts.JsxEmit.React,
+        target: ts.ScriptTarget.ESNext,
+        module: ts.ModuleKind.CommonJS,
+        strict: true,
+        skipLibCheck: true,
     };
-    logDebug('Loading', root);
-    logDebug('Loading', root);
-    let program = ts.createProgram([root], options);
-    logDebug('Compiled');
-    validateProgram(program);
-    logDebug('Validated');
-    let sources = getSources(program);
-    let docInfo = { interfaces: {}, components: {}, hooks: {}, functions: {}, unions: {} };
-    for (var i = 0; i < sources.length; i++) {
-        let source = sources[i];
-        logDebug('Loading', source);
-        let sourceNode = program.getSourceFile(source);
-        if (!sourceNode) {
+    (0, logger_1.logDebug)('Loading', root);
+    const program = ts.createProgram([root], options);
+    (0, logger_1.logDebug)('Compiled');
+    const checker = program.getTypeChecker();
+    (0, analyzer_1.validateProgram)(program);
+    (0, logger_1.logDebug)('Validated');
+    const sources = (0, analyzer_1.getSources)(program);
+    const docInfo = { interfaces: {}, components: {}, hooks: {}, functions: {}, unions: {}, enums: {}, typeAliases: {} };
+    for (const source of sources) {
+        (0, logger_1.logDebug)('Loading', source);
+        const sourceNode = program.getSourceFile(source);
+        if (!sourceNode)
             continue;
-        }
         try {
-            walkTree(sourceNode, docInfo);
+            (0, analyzer_1.walkTree)(sourceNode, docInfo, checker);
         }
         catch (error) {
-            logError(`Error in ${source}: ${error}`);
+            (0, logger_1.logError)(`Error in ${source}: ${error}`);
         }
     }
-    let docs = generateDocObject(docInfo);
-    return [docInfo, docs];
-    /*
-        for(let i in docInfo.components) {
-            let c = docInfo.components[i];
-            let inf = docInfo.interfaces[c.propType];
-            if (!!inf) {
-                console.log(inf.comment);
-                console.log(inf.code);
-            }
-            console.log(c.comment);
-            console.log(`export const ${c.name} : React.FunctionComponent<${c.propType}>;`)
-        }*/
-}
-function generateHookDoc(cdoc, docs) {
-    let md = new MarkdownBuilder();
-    md.addTitle(cdoc.name, 1);
-    md.addParagraph(cdoc.summary);
-    md.addTitle('Installation', 2);
-    md.addCode(`import {${cdoc.name}} from 'uxp/components';`);
-    if (cdoc.examples.length > 0) {
-        md.addTitle('Examples', 2);
-        for (let i in cdoc.examples) {
-            md.addCode(cdoc.examples[i].summary);
-        }
-    }
-    return md.toString();
-}
-function generateTypeDoc(cdoc, docs) {
-    let md = new MarkdownBuilder();
-    md.addTitle(cdoc.name, 1);
-    md.addParagraph(cdoc.summary);
-    md.addCode(cdoc.code);
-    md.addTitle('Usage', 2);
-    md.addCode(`import {${cdoc.name}} from 'uxp/components';`);
-    if (cdoc.examples.length > 0) {
-        md.addTitle('Examples', 2);
-        for (let i in cdoc.examples) {
-            md.addCode(cdoc.examples[i].summary);
-        }
-    }
-    return md.toString();
-}
-function linkedType(t, docs) {
-    if (docs.types.find(x => x.name.toUpperCase() == t.toUpperCase())) {
-        return `[${t}](../types/${t}.md)`;
-    }
-    return t;
+    return docInfo;
 }
-function generateComponentDoc(cdoc, docs) {
-    let md = new MarkdownBuilder();
-    md.addTitle(cdoc.name, 1);
-    md.addParagraph(cdoc.summary);
-    md.addTitle('Installation', 2);
-    md.addCode(`import {${cdoc.name}} from 'uxp/components';`);
-    if (cdoc.examples.length > 0) {
-        md.addTitle('Examples', 2);
-        for (let i in cdoc.examples) {
-            md.addCode(cdoc.examples[i].summary);
-        }
-    }
-    if (cdoc.props.length > 0) {
-        md.addTitle('Properties', 2);
-        md.addTable(cdoc.props.map(p => ({ Name: p.name, Type: linkedType(p.type, docs), Description: p.summary })));
-        for (let i in cdoc.props) {
-            let prop = cdoc.props[i];
-            md.addTitle(prop.name, 3);
-            md.addParagraph('---');
-            md.addParagraph(prop.summary);
-            md.addTable([{ 'type': linkedType(prop.type, docs) }]);
-            for (let j in prop.examples) {
-                md.addCode(prop.examples[j].summary);
-            }
-        }
-    }
-    return md.toString();
-}
-function generateDocs(root, outputPath) {
-    let [docInfo, docs] = load(root);
-    let components = docs.components;
+exports.load = load;
+function generateDocs(root, outputPath, moduleName) {
+    var _a, _b, _c, _d, _e;
+    const docInfo = load(root);
     if (outputPath.endsWith('/'))
         outputPath = outputPath.substring(0, outputPath.length - 1);
-    mkdirp_1.default.sync(outputPath + '/components/');
-    mkdirp_1.default.sync(outputPath + '/types/');
-    mkdirp_1.default.sync(outputPath + '/hooks/');
-    for (let i in components) {
-        let component = components[i];
-        if (ComponentFlags.Export === (component.flags & ComponentFlags.Export)) {
-            let md = generateComponentDoc(component, docs);
-            let path = outputPath + '/components/' + component.name + '.md';
-            console.log(chalk_1.default.gray('Writing component', component.name, 'to', path));
-            fs.writeFileSync(path, md.toString());
-        }
-    }
-    for (let i in docs.types) {
-        let type = docs.types[i];
-        if (ComponentFlags.Export === (type.flags & ComponentFlags.Export)) {
-            let md = generateTypeDoc(type, docs);
-            let path = outputPath + '/types/' + type.name + '.md';
-            console.log(chalk_1.default.gray('Writing type', type.name, 'to', path));
-            fs.writeFileSync(path, md.toString());
-        }
-    }
-    for (let i in docs.hooks) {
-        let hook = docs.hooks[i];
-        if (ComponentFlags.Export === (hook.flags & ComponentFlags.Export)) {
-            let md = generateHookDoc(hook, docs);
-            let path = outputPath + '/hooks/' + hook.name + '.md';
-            console.log(chalk_1.default.gray('Writing hook', hook.name, 'to', path));
-            fs.writeFileSync(path, md.toString());
+    (0, file_1.createDirectories)([
+        `${outputPath}/components`,
+        `${outputPath}/types`,
+        `${outputPath}/hooks`,
+        `${outputPath}/functions`
+    ]);
+    const dependentTypes = (0, module_1.collectAllDependentTypes)(docInfo);
+    for (const cn in docInfo.components) {
+        const componentInfo = docInfo.components[cn];
+        if ((0, type_helpers_1.hasExportAnnotation)(componentInfo.comment)) {
+            const md = (0, component_1.generateComponentDocFromDocInfo)(componentInfo, docInfo, moduleName, dependentTypes);
+            const path = `${outputPath}/components/${componentInfo.name}.md`;
+            (0, logger_1.logDebug)('Writing component', componentInfo.name, 'to', path);
+            (0, file_1.writeFile)(path, md);
+        }
+    }
+    for (const typeName of dependentTypes) {
+        if ((_a = docInfo.interfaces) === null || _a === void 0 ? void 0 : _a[typeName]) {
+            const typeInfo = docInfo.interfaces[typeName];
+            const md = (0, type_1.generateTypeDocFromDocInfo)(typeInfo, 'interface', docInfo, moduleName, dependentTypes);
+            const path = `${outputPath}/types/${typeInfo.name}.md`;
+            (0, logger_1.logDebug)('Writing type', typeInfo.name, 'to', path);
+            (0, file_1.writeFile)(path, md);
+        }
+        else if ((_b = docInfo.unions) === null || _b === void 0 ? void 0 : _b[typeName]) {
+            const typeInfo = docInfo.unions[typeName];
+            const md = (0, type_1.generateTypeDocFromDocInfo)(typeInfo, 'union', docInfo, moduleName, dependentTypes);
+            const path = `${outputPath}/types/${typeName}.md`;
+            (0, logger_1.logDebug)('Writing type', typeName, 'to', path);
+            (0, file_1.writeFile)(path, md);
+        }
+        else if ((_c = docInfo.enums) === null || _c === void 0 ? void 0 : _c[typeName]) {
+            const typeInfo = docInfo.enums[typeName];
+            const md = (0, type_1.generateTypeDocFromDocInfo)(typeInfo, 'enum', docInfo, moduleName, dependentTypes);
+            const path = `${outputPath}/types/${typeInfo.name}.md`;
+            (0, logger_1.logDebug)('Writing type', typeInfo.name, 'to', path);
+            (0, file_1.writeFile)(path, md);
+        }
+        else if ((_d = docInfo.typeAliases) === null || _d === void 0 ? void 0 : _d[typeName]) {
+            const typeInfo = docInfo.typeAliases[typeName];
+            const md = (0, type_1.generateTypeDocFromDocInfo)(typeInfo, 'type', docInfo, moduleName, dependentTypes);
+            const path = `${outputPath}/types/${typeInfo.name}.md`;
+            (0, logger_1.logDebug)('Writing type', typeInfo.name, 'to', path);
+            (0, file_1.writeFile)(path, md);
+        }
+        else if ((_e = docInfo.functions) === null || _e === void 0 ? void 0 : _e[typeName]) {
+            const typeInfo = docInfo.functions[typeName];
+            const md = (0, function_1.generateFunctionDocFromDocInfo)(typeInfo, docInfo, moduleName, dependentTypes);
+            const path = `${outputPath}/types/${typeName}.md`;
+            (0, logger_1.logDebug)('Writing function type', typeName, 'to', path);
+            (0, file_1.writeFile)(path, md);
+        }
+    }
+    for (const hn in docInfo.hooks) {
+        const hookInfo = docInfo.hooks[hn];
+        if ((0, type_helpers_1.hasExportAnnotation)(hookInfo.comment)) {
+            const md = (0, hook_1.generateHookDocFromDocInfo)(hookInfo, docInfo, moduleName, dependentTypes);
+            const path = `${outputPath}/hooks/${hookInfo.name}.md`;
+            (0, logger_1.logDebug)('Writing hook', hookInfo.name, 'to', path);
+            (0, file_1.writeFile)(path, md);
+        }
+    }
+    for (const fn in docInfo.functions) {
+        if (!dependentTypes.has(fn)) {
+            const functionInfo = docInfo.functions[fn];
+            if ((0, type_helpers_1.hasExportAnnotation)(functionInfo.comment)) {
+                const md = (0, function_1.generateFunctionDocFromDocInfo)(functionInfo, docInfo, moduleName, dependentTypes);
+                const path = `${outputPath}/functions/${fn}.md`;
+                (0, logger_1.logDebug)('Writing function', fn, 'to', path);
+                (0, file_1.writeFile)(path, md);
+            }
         }
     }
 }
+exports.generateDocs = generateDocs;
 function generateTypeDefinition(root, outputPath, moduleName) {
-    let [docInfo, docs] = load(root);
-    let moduleCode = generateExportModule(docs, docInfo, { moduleName: moduleName || 'module' });
-    fs.writeFileSync(outputPath, moduleCode);
-}
-function main() {
-    try {
-        let cmd = clap_1.default
-            .command('react-tsdoc')
-            .description('Generate docs for React components')
-            .version('0.0.1');
-        cmd.command('types [input.ts] [output.t.ds]')
-            .option('--module-name <name>')
-            .action((actionArgs) => {
-            let args = actionArgs.args || [];
-            let options = actionArgs.options || {};
-            generateTypeDefinition(args[0], args[1], options.moduleName);
-        });
-        cmd.command('docs [input.ts] [output-folder]')
-            .action((actionArgs) => {
-            let { args, options } = actionArgs;
-            generateDocs(args[0], args[1]);
-        });
-        cmd.run();
-    }
-    catch (e) {
-        console.error(chalk_1.default.red(e));
-    }
+    const docInfo = load(root);
+    const moduleCode = (0, module_1.generateExportModule)(docInfo, { moduleName: moduleName || 'module' });
+    (0, file_1.writeFile)(outputPath, moduleCode);
 }
-exports.main = main;
+exports.generateTypeDefinition = generateTypeDefinition;
 //# sourceMappingURL=index.js.map