├── demo ├── d3Data.json ├── mermaidDemo.css ├── mermaidDemo.html ├── d3Demo.html ├── mermaidDemo.js ├── d3Demo.css ├── mermaid.graph └── d3NodeTypes.js ├── src ├── __tests__ │ ├── code-samples │ │ ├── code8.jsx │ │ ├── code11.ts │ │ ├── code2.ts │ │ ├── code5.ts │ │ ├── code9.ts │ │ ├── code10.ts │ │ ├── code7.ts │ │ ├── code14.ts │ │ ├── code12.ts │ │ ├── code3.ts │ │ ├── code13.ts │ │ └── code.ts │ ├── graph.spec.ts │ ├── code5.spec.ts │ ├── code7.spec.ts │ ├── code8.spec.ts │ ├── code6.spec.ts │ └── code4.spec.ts ├── parsers │ ├── AnyTypeAnnotation.ts │ ├── Block.ts │ ├── Class.ts │ ├── Binary.ts │ ├── Directive.ts │ ├── EnumBody.ts │ ├── DoExpression.ts │ ├── BlockParent.ts │ ├── BlockStatement.ts │ ├── Declaration.ts │ ├── EmptyStatement.ts │ ├── BigIntLiteral.ts │ ├── BooleanLiteral.ts │ ├── BreakStatement.ts │ ├── DirectiveLiteral.ts │ ├── NumberLiteral.ts │ ├── NumericLiteral.ts │ ├── DeclareModule.ts │ ├── StringLiteral.ts │ ├── ArrayExpression.ts │ ├── ClassImplements.ts │ ├── Conditional.ts │ ├── ContinueStatement.ts │ ├── DebuggerStatement.ts │ ├── DeclareFunction.ts │ ├── DeclareVariable.ts │ ├── DoWhileStatement.ts │ ├── EnumBooleanBody.ts │ ├── PrivateName.ts │ ├── DeclareClass.ts │ ├── DeclareInterface.ts │ ├── DeclareTypeAlias.ts │ ├── ArgumentPlaceholder.ts │ ├── ClassExpression.ts │ ├── DeclareOpaqueType.ts │ ├── DeclaredPredicate.ts │ ├── Decorator.ts │ ├── File.ts │ ├── ArrayTypeAnnotation.ts │ ├── BindExpression.ts │ ├── CatchClause.ts │ ├── ClassDeclaration.ts │ ├── Import.ts │ ├── Super.ts │ ├── CompletionStatement.ts │ ├── DeclareModuleExports.ts │ ├── JSXText.ts │ ├── Program.ts │ ├── BooleanLiteralTypeAnnotation.ts │ ├── BooleanTypeAnnotation.ts │ ├── Property.ts │ ├── TSThisType.ts │ ├── EmptyTypeAnnotation.ts │ ├── For.ts │ ├── ForStatement.ts │ ├── JSX.ts │ ├── NullLiteral.ts │ ├── TSAnyKeyword.ts │ ├── TryStatement.ts │ ├── Flow.ts │ ├── LVal.ts │ ├── Loop.ts │ ├── Noop.ts │ ├── TSModuleBlock.ts │ ├── TSNullKeyword.ts │ ├── TSVoidKeyword.ts │ ├── ConditionalExpression.ts │ ├── DeclareExportDeclaration.ts │ ├── JSXIdentifier.ts │ ├── MetaProperty.ts │ ├── TSInterfaceBody.ts │ ├── TSNeverKeyword.ts │ ├── ThisExpression.ts │ ├── While.ts │ ├── Literal.ts │ ├── Method.ts │ ├── ObjectExpression.ts │ ├── Pattern.ts │ ├── Private.ts │ ├── Pureish.ts │ ├── TSBigIntKeyword.ts │ ├── TSNumberKeyword.ts │ ├── TSObjectKeyword.ts │ ├── TSStringKeyword.ts │ ├── TSSymbolKeyword.ts │ ├── TSType.ts │ ├── TemplateLiteral.ts │ ├── FlowType.ts │ ├── Function.ts │ ├── JSXClosingFragment.ts │ ├── JSXEmptyExpression.ts │ ├── JSXOpeningFragment.ts │ ├── Scopable.ts │ ├── TSBooleanKeyword.ts │ ├── TSUnknownKeyword.ts │ ├── TemplateElement.ts │ ├── UpdateExpression.ts │ ├── Variance.ts │ ├── ExportSpecifier.ts │ ├── Immutable.ts │ ├── Statement.ts │ ├── TSEnumMember.ts │ ├── TSTypeQuery.ts │ ├── TSUndefinedKeyword.ts │ ├── TypeAlias.ts │ ├── UnaryLike.ts │ ├── AwaitExpression.ts │ ├── EnumMember.ts │ ├── Expression.ts │ ├── ModuleDeclaration.ts │ ├── ObjectProperty.ts │ ├── OpaqueType.ts │ ├── RegExpLiteral.ts │ ├── SwitchCase.ts │ ├── TSLiteralType.ts │ ├── DeclareExportAllDeclaration.ts │ ├── IfStatement.ts │ ├── ObjectMember.ts │ ├── PatternLike.ts │ ├── Placeholder.ts │ ├── RegexLiteral.ts │ ├── RestElement.ts │ ├── RestProperty.ts │ ├── TSArrayType.ts │ ├── TSEntityName.ts │ ├── TSImportType.ts │ ├── FlowPredicate.ts │ ├── ForXStatement.ts │ ├── SpreadElement.ts │ ├── TSRestType.ts │ ├── TSTupleType.ts │ ├── TSTypeElement.ts │ ├── TSTypeLiteral.ts │ ├── TSTypeReference.ts │ ├── TypeParameter.ts │ ├── EnumNumberBody.ts │ ├── EnumStringBody.ts │ ├── EnumSymbolBody.ts │ ├── FunctionParent.ts │ ├── ImportSpecifier.ts │ ├── JSXSpreadChild.ts │ ├── LabeledStatement.ts │ ├── PipelineBareFunction.ts │ ├── ReturnStatement.ts │ ├── SpreadProperty.ts │ ├── TSInferType.ts │ ├── Terminatorless.ts │ ├── ThrowStatement.ts │ ├── TypeAnnotation.ts │ ├── WhileStatement.ts │ ├── CallExpression.ts │ ├── EnumDeclaration.ts │ ├── FlowDeclaration.ts │ ├── JSXClosingElement.ts │ ├── ModuleSpecifier.ts │ ├── TSOptionalType.ts │ ├── TSUnionType.ts │ ├── TupleExpression.ts │ ├── WithStatement.ts │ ├── YieldExpression.ts │ ├── EnumBooleanMember.ts │ ├── EnumNumberMember.ts │ ├── EnumStringMember.ts │ ├── ExportDeclaration.ts │ ├── ExpressionStatement.ts │ ├── ExpressionWrapper.ts │ ├── FunctionTypeParam.ts │ ├── InferredPredicate.ts │ ├── InterfaceExtends.ts │ ├── JSXSpreadAttribute.ts │ ├── MemberExpression.ts │ ├── ObjectTypeIndexer.ts │ ├── RecordExpression.ts │ ├── SwitchStatement.ts │ ├── TSConstructorType.ts │ ├── TSExportAssignment.ts │ ├── TSTypeAnnotation.ts │ ├── UnaryExpression.ts │ ├── UserWhitespacable.ts │ ├── ExportAllDeclaration.ts │ ├── FlowBaseAnnotation.ts │ ├── JSXExpressionContainer.ts │ ├── ObjectTypeProperty.ts │ ├── TSNonNullExpression.ts │ ├── ThisTypeAnnotation.ts │ ├── TypeCastExpression.ts │ ├── VoidTypeAnnotation.ts │ ├── AssignmentExpression.ts │ ├── EnumDefaultedMember.ts │ ├── ExportDefaultSpecifier.ts │ ├── ExportNamedDeclaration.ts │ ├── JSXAttribute.ts │ ├── MixedTypeAnnotation.ts │ ├── ObjectPattern.ts │ ├── TSModuleDeclaration.ts │ ├── TSParenthesizedType.ts │ ├── TSTypeOperator.ts │ ├── TupleTypeAnnotation.ts │ ├── UnionTypeAnnotation.ts │ ├── ExistsTypeAnnotation.ts │ ├── InterfaceDeclaration.ts │ ├── InterpreterDirective.ts │ ├── NumberTypeAnnotation.ts │ ├── ObjectTypeAnnotation.ts │ ├── ParenthesizedExpression.ts │ ├── StringTypeAnnotation.ts │ ├── SymbolTypeAnnotation.ts │ ├── TSExternalModuleReference.ts │ ├── TSInterfaceDeclaration.ts │ ├── TSIntersectionType.ts │ ├── TypeofTypeAnnotation.ts │ ├── ExportDefaultDeclaration.ts │ ├── ExportNamespaceSpecifier.ts │ ├── FunctionTypeAnnotation.ts │ ├── GenericTypeAnnotation.ts │ ├── NullableTypeAnnotation.ts │ ├── ObjectTypeCallProperty.ts │ ├── ObjectTypeInternalSlot.ts │ ├── SequenceExpression.ts │ ├── TSQualifiedName.ts │ ├── TaggedTemplateExpression.ts │ ├── V8IntrinsicIdentifier.ts │ ├── InterfaceTypeAnnotation.ts │ ├── PipelineTopicExpression.ts │ ├── QualifiedTypeIdentifier.ts │ ├── ObjectTypeSpreadProperty.ts │ ├── TSTypeParameterInstantiation.ts │ ├── TypeParameterDeclaration.ts │ ├── VariableDeclarator.ts │ ├── NullLiteralTypeAnnotation.ts │ ├── TSNamespaceExportDeclaration.ts │ ├── ForInStatement.ts │ ├── ForOfStatement.ts │ ├── IntersectionTypeAnnotation.ts │ ├── NumberLiteralTypeAnnotation.ts │ ├── StringLiteralTypeAnnotation.ts │ ├── TypeParameterInstantiation.ts │ ├── TSTypeParameterDeclaration.ts │ ├── PipelinePrimaryTopicReference.ts │ ├── JSXNamespacedName.ts │ ├── TSAsExpression.ts │ ├── TSEnumDeclaration.ts │ ├── TSFunctionType.ts │ ├── TSMappedType.ts │ ├── AssignmentPattern.ts │ ├── ClassProperty.ts │ ├── JSXMemberExpression.ts │ ├── TSIndexSignature.ts │ ├── TSPropertySignature.ts │ ├── TSTypeAssertion.ts │ ├── TSTypePredicate.ts │ ├── BinaryExpression.ts │ ├── LogicalExpression.ts │ ├── TSIndexedAccessType.ts │ ├── JSXElement.ts │ ├── NewExpression.ts │ ├── TSTypeAliasDeclaration.ts │ ├── ClassPrivateMethod.ts │ ├── JSXFragment.ts │ ├── OptionalMemberExpression.ts │ ├── TSParameterProperty.ts │ ├── ClassPrivateProperty.ts │ ├── ImportDeclaration.ts │ ├── TSImportEqualsDeclaration.ts │ ├── TSTypeParameter.ts │ ├── TSCallSignatureDeclaration.ts │ ├── OptionalCallExpression.ts │ ├── TSExpressionWithTypeArguments.ts │ ├── TSMethodSignature.ts │ ├── ArrayPattern.ts │ ├── ClassBody.ts │ ├── VariableDeclaration.ts │ ├── JSXOpeningElement.ts │ ├── TSConstructSignatureDeclaration.ts │ ├── TSDeclareFunction.ts │ ├── ImportNamespaceSpecifier.ts │ ├── TSConditionalType.ts │ ├── FunctionDeclaration.ts │ ├── TSDeclareMethod.ts │ ├── ObjectMethod.ts │ ├── ImportDefaultSpecifier.ts │ ├── FunctionExpression.ts │ ├── ClassMethod.ts │ ├── Identifier.ts │ └── ArrowFunctionExpression.ts ├── constants.ts ├── __helpers__ │ └── index.ts ├── types.ts ├── sort.ts ├── utils.ts ├── parse.ts └── graph.ts ├── .npmignore ├── .babelrc ├── jest └── index.ts ├── tsconfig.json ├── node └── code-inspector.d.ts ├── webpack.node.js ├── webpack.browser.js ├── LICENSE ├── .eslintrc ├── .gitignore ├── scripts └── generate.js └── package.json /demo/d3Data.json: -------------------------------------------------------------------------------- 1 | { 2 | "nodes": [], 3 | "links": [] 4 | } -------------------------------------------------------------------------------- /src/__tests__/code-samples/code8.jsx: -------------------------------------------------------------------------------- 1 | import { useState } from 'react'; 2 | -------------------------------------------------------------------------------- /src/__tests__/code-samples/code11.ts: -------------------------------------------------------------------------------- 1 | function createGraphItem() { 2 | const label = 'foo'; 3 | } 4 | -------------------------------------------------------------------------------- /src/__tests__/code-samples/code2.ts: -------------------------------------------------------------------------------- 1 | const ANSWER = 42; 2 | 3 | class Moo { 4 | private a = 100; 5 | 6 | public go() { 7 | return 'ok'; 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /.npmignore: -------------------------------------------------------------------------------- 1 | src 2 | .babelrc 3 | .eslintrc 4 | tsconfig.json 5 | webpack.browser.json 6 | webpack.node.json 7 | yarn.lock 8 | demo 9 | jest 10 | scripts 11 | webpack.*.js -------------------------------------------------------------------------------- /src/__tests__/code-samples/code5.ts: -------------------------------------------------------------------------------- 1 | const util = () => { 2 | function doSomething() { 3 | // something 4 | new App('foo', 'bar', () => { 5 | // something else 6 | }); 7 | } 8 | }; 9 | -------------------------------------------------------------------------------- /.babelrc: -------------------------------------------------------------------------------- 1 | { 2 | "presets": [ 3 | "@babel/preset-env", 4 | "@babel/preset-typescript" 5 | ], 6 | "plugins": [ 7 | "@babel/plugin-transform-regenerator", 8 | "@babel/plugin-transform-runtime" 9 | ] 10 | } -------------------------------------------------------------------------------- /src/parsers/AnyTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode } from '../types'; 4 | 5 | export default function(node: T.AnyTypeAnnotation): NormalizedNode | undefined { 6 | return undefined; 7 | } 8 | -------------------------------------------------------------------------------- /src/parsers/Block.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function(node: T.Block, helpers: ParserHelpers): NormalizedNode { 6 | return { 7 | type: 'Block', 8 | text: 'Block', 9 | ...helpers.normalizeLoc(node.loc), 10 | }; 11 | } 12 | -------------------------------------------------------------------------------- /src/parsers/Class.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function(node: T.Class, helpers: ParserHelpers): NormalizedNode { 6 | return { 7 | type: 'Class', 8 | text: 'Class', 9 | ...helpers.normalizeLoc(node.loc), 10 | }; 11 | } 12 | -------------------------------------------------------------------------------- /src/__tests__/code-samples/code9.ts: -------------------------------------------------------------------------------- 1 | /* eslint-disable no-var */ 2 | // @ts-ignore 3 | const A = 'AAAA'; 4 | var b = 'bbb'; 5 | const c = 'ccc'; 6 | const d: number[] = []; 7 | 8 | function foobar(valueA, valueB) { 9 | const e = 2; 10 | let f = 0; 11 | for (let i = 0; i < 10; i++) { 12 | f += i; 13 | d.push(i); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /src/__tests__/code-samples/code10.ts: -------------------------------------------------------------------------------- 1 | function foobar() { 2 | const ANSWER = 42; 3 | return ANSWER; 4 | } 5 | function barfoo() { 6 | return 'N'; 7 | } 8 | const AAA = 'xxx'; 9 | class MyClass { 10 | public greeting = 'Hello'; 11 | 12 | greeting() { 13 | const text = `${this.greeting} John`; 14 | console.log(text); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/__tests__/code-samples/code7.ts: -------------------------------------------------------------------------------- 1 | function parseItems( 2 | items: any[], 3 | parent: Traverse.Node, 4 | grandParent: Traverse.Node, 5 | delimiter = ',' 6 | ): string { 7 | if (items.length > 0) { 8 | return items 9 | .map(i => parse(i, parent, grandParent).text) 10 | .join(`${delimiter} `); 11 | } 12 | return ''; 13 | } 14 | -------------------------------------------------------------------------------- /src/parsers/Binary.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Binary, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'Binary', 11 | text: 'Binary', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/__tests__/code-samples/code14.ts: -------------------------------------------------------------------------------- 1 | function A(foo, bar) {} 2 | const B = function Name(foo, bar) {}; 3 | const C = (foo, bar) => {}; 4 | 5 | (function(foo, bar) {}); 6 | 7 | const Obj = { 8 | D(foo, bar) {}, 9 | E(foo, bar) {}, 10 | F: (foo, bar) => {}, 11 | }; 12 | 13 | class F { 14 | constructor(foo, bar) {} 15 | 16 | G(foo, bar) {} 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/Directive.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Directive, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'Directive', 11 | text: '', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/EnumBody.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.EnumBody, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'EnumBody', 11 | text: 'EnumBody', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/DoExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.DoExpression, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'DoExpression', 11 | text: 'do', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/BlockParent.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.BlockParent, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'BlockParent', 11 | text: 'BlockParent', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/BlockStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.BlockStatement, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'BlockStatement', 11 | text: '⊏…⊐', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/Declaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Declaration, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'Declaration', 11 | text: 'Declaration', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/EmptyStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.EmptyStatement, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'EmptyStatement', 11 | text: '☐', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/BigIntLiteral.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.BigIntLiteral, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'BigIntLiteral', 11 | text: node.value, 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/BooleanLiteral.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.BooleanLiteral, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'BooleanLiteral', 11 | text: node.value, 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/BreakStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.BreakStatement, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'BreakStatement', 11 | text: 'break', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/DirectiveLiteral.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.DirectiveLiteral, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'DirectiveLiteral', 11 | text: '', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/NumberLiteral.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.NumberLiteral, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'NumberLiteral', 11 | text: node.value, 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/NumericLiteral.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.NumericLiteral, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'NumericLiteral', 11 | text: node.value, 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /jest/index.ts: -------------------------------------------------------------------------------- 1 | import { CustomConsole, LogType, LogMessage } from '@jest/console'; 2 | 3 | function simpleFormatter(type: LogType, message: LogMessage): string { 4 | return message 5 | .split(/\n/) 6 | .map(line => line) 7 | .join('\n'); 8 | } 9 | 10 | global.console = new CustomConsole( 11 | process.stdout, 12 | process.stderr, 13 | simpleFormatter 14 | ); 15 | -------------------------------------------------------------------------------- /src/parsers/DeclareModule.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.DeclareModule, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'DeclareModule', 11 | text: 'DeclareModule', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/StringLiteral.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.StringLiteral, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'StringLiteral', 11 | text: `"${node.value}"`, 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/ArrayExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ArrayExpression, 7 | { normalizeLoc }: ParserHelpers 8 | ): NormalizedNode | undefined { 9 | return { 10 | type: 'ArrayExpression', 11 | text: '[]', 12 | ...normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/ClassImplements.ts: -------------------------------------------------------------------------------- 1 | // flow 2 | import T from '@babel/types'; 3 | 4 | import { NormalizedNode, ParserHelpers } from '../types'; 5 | 6 | export default function( 7 | node: T.ClassImplements, 8 | helpers: ParserHelpers 9 | ): NormalizedNode { 10 | return { 11 | type: 'ClassImplements', 12 | text: '', 13 | ...helpers.normalizeLoc(node.loc), 14 | }; 15 | } 16 | -------------------------------------------------------------------------------- /src/parsers/Conditional.ts: -------------------------------------------------------------------------------- 1 | // flow 2 | import T from '@babel/types'; 3 | 4 | import { NormalizedNode, ParserHelpers } from '../types'; 5 | 6 | export default function( 7 | node: T.Conditional, 8 | helpers: ParserHelpers 9 | ): NormalizedNode { 10 | return { 11 | type: 'Conditional', 12 | text: 'Conditional', 13 | ...helpers.normalizeLoc(node.loc), 14 | }; 15 | } 16 | -------------------------------------------------------------------------------- /src/parsers/ContinueStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ContinueStatement, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'ContinueStatement', 11 | text: 'continue', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/DebuggerStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.DebuggerStatement, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'DebuggerStatement', 11 | text: 'debugger', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/DeclareFunction.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.DeclareFunction, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'DeclareFunction', 11 | text: 'DeclareFunction', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/DeclareVariable.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.DeclareVariable, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'DeclareVariable', 11 | text: 'DeclareVariable', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/DoWhileStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.DoWhileStatement, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'DoWhileStatement', 11 | text: 'do/while', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/EnumBooleanBody.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.EnumBooleanBody, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'EnumBooleanBody', 11 | text: 'EnumBooleanBody', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/PrivateName.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.PrivateName, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'PrivateName', 11 | text: helpers.parse(node.id).text, 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/DeclareClass.ts: -------------------------------------------------------------------------------- 1 | // flow 2 | import T from '@babel/types'; 3 | 4 | import { NormalizedNode, ParserHelpers } from '../types'; 5 | 6 | export default function( 7 | node: T.DeclareClass, 8 | helpers: ParserHelpers 9 | ): NormalizedNode { 10 | return { 11 | type: 'DeclareClass', 12 | text: 'DeclareClass', 13 | ...helpers.normalizeLoc(node.loc), 14 | }; 15 | } 16 | -------------------------------------------------------------------------------- /src/parsers/DeclareInterface.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.DeclareInterface, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'DeclareInterface', 11 | text: 'DeclareInterface', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/DeclareTypeAlias.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.DeclareTypeAlias, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'DeclareTypeAlias', 11 | text: 'DeclareTypeAlias', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/ArgumentPlaceholder.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode } from '../types'; 4 | 5 | export default function( 6 | node: T.ArgumentPlaceholder, 7 | { normalizeLoc }: { normalizeLoc: Function } 8 | ): NormalizedNode | undefined { 9 | return { 10 | type: 'ArgumentPlaceholder', 11 | text: '?', 12 | ...normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/ClassExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ClassExpression, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'ClassExpression', 11 | text: helpers.parse(node.id).text, 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/DeclareOpaqueType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.DeclareOpaqueType, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'DeclareOpaqueType', 11 | text: 'DeclareOpaqueType', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/DeclaredPredicate.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.DeclaredPredicate, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'DeclaredPredicate', 11 | text: 'DeclaredPredicate', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/Decorator.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Decorator, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'Decorator', 11 | text: `@${helpers.parse(node.expression).text}`, 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/File.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.File, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'File', 13 | text: 'file', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/constants.ts: -------------------------------------------------------------------------------- 1 | export const NODES_FUNCTION_SCOPES: Record = { 2 | FunctionDeclaration: true, 3 | FunctionExpression: true, 4 | ArrowFunctionExpression: true, 5 | ClassMethod: true, 6 | ObjectMethod: true, 7 | }; 8 | export const NODES_DEFINING_SCOPES: Record = { 9 | Program: true, 10 | ClassDeclaration: true, 11 | ...NODES_FUNCTION_SCOPES, 12 | }; 13 | -------------------------------------------------------------------------------- /src/parsers/ArrayTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | /* Flow */ 2 | import T from '@babel/types'; 3 | 4 | import { NormalizedNode, ParserHelpers } from '../types'; 5 | 6 | export default function( 7 | node: T.ArrayTypeAnnotation, 8 | helpers: ParserHelpers 9 | ): NormalizedNode { 10 | return { 11 | type: 'ArrayTypeAnnotation', 12 | text: '', 13 | ...helpers.normalizeLoc(node.loc), 14 | }; 15 | } 16 | -------------------------------------------------------------------------------- /src/parsers/BindExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.BindExpression, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'BindExpression', 11 | text: helpers.parse(node.callee).text, 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/CatchClause.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.CatchClause, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'CatchClause', 11 | text: `catch(${helpers.parse(node.param).text})`, 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/ClassDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ClassDeclaration, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'ClassDeclaration', 11 | text: helpers.parse(node.id).text, 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/Import.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Import, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'Import', 13 | text: 'import', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/Super.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Super, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'Super', 13 | text: `super`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/CompletionStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.CompletionStatement, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'CompletionStatement', 11 | text: 'CompletionStatement', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/DeclareModuleExports.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.DeclareModuleExports, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'DeclareModuleExports', 11 | text: 'DeclareModuleExports', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/JSXText.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.JSXText, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'JSXText', 13 | text: node.value, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/Program.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Program, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'Program', 13 | text: 'Program', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/BooleanLiteralTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.BooleanLiteralTypeAnnotation, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'BooleanLiteralTypeAnnotation', 11 | text: '', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/BooleanTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.BooleanTypeAnnotation, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'BooleanTypeAnnotation', 11 | text: 'BooleanTypeAnnotation', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/Property.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Property, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'Property', 13 | text: 'Property', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSThisType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSThisType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSThisType', 13 | text: 'this', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/EmptyTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | // flow 2 | import T from '@babel/types'; 3 | 4 | import { NormalizedNode, ParserHelpers } from '../types'; 5 | 6 | export default function( 7 | node: T.EmptyTypeAnnotation, 8 | helpers: ParserHelpers 9 | ): NormalizedNode { 10 | return { 11 | type: 'EmptyTypeAnnotation', 12 | text: 'EmptyTypeAnnotation', 13 | ...helpers.normalizeLoc(node.loc), 14 | }; 15 | } 16 | -------------------------------------------------------------------------------- /src/parsers/For.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.For, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'For', 14 | text: 'For', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ForStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ForStatement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ForStatement', 13 | text: 'for', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/JSX.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.JSX, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'JSX', 14 | text: 'JSX', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/NullLiteral.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.NullLiteral, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'NullLiteral', 13 | text: 'null', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSAnyKeyword.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSAnyKeyword, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSAnyKeyword', 13 | text: 'any', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TryStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TryStatement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TryStatement', 13 | text: 'try', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/Flow.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Flow, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'Flow', 14 | text: 'Flow', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/LVal.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.LVal, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'LVal', 14 | text: 'LVal', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/Loop.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Loop, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'Loop', 14 | text: 'Loop', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/Noop.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Noop, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'Noop', 14 | text: 'Noop', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/TSModuleBlock.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSModuleBlock, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSModuleBlock', 13 | text: '{…}', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSNullKeyword.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSNullKeyword, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSNullKeyword', 13 | text: 'null', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSVoidKeyword.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSVoidKeyword, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSVoidKeyword', 13 | text: 'void', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/ConditionalExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ConditionalExpression, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'ConditionalExpression', 11 | text: `${helpers.parse(node.test).text}?`, 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/DeclareExportDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.DeclareExportDeclaration, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'DeclareExportDeclaration', 11 | text: 'DeclareExportDeclaration', 12 | ...helpers.normalizeLoc(node.loc), 13 | }; 14 | } 15 | -------------------------------------------------------------------------------- /src/parsers/JSXIdentifier.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.JSXIdentifier, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'JSXIdentifier', 13 | text: node.name, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/MetaProperty.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.MetaProperty, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'MetaProperty', 13 | text: 'MetaProperty', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSInterfaceBody.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSInterfaceBody, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSInterfaceBody', 13 | text: '{…}', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSNeverKeyword.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSNeverKeyword, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSNeverKeyword', 13 | text: 'never', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/ThisExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ThisExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ThisExpression', 13 | text: 'this', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/While.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.While, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'While', 14 | text: 'While', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/Literal.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Literal, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'Literal', 14 | text: 'Literal', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/Method.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Method, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'Method', 14 | text: 'Method', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ObjectExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ObjectExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ObjectExpression', 13 | text: '{…}', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/Pattern.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Pattern, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'Pattern', 14 | text: 'Pattern', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/Private.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Private, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'Private', 14 | text: 'Private', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/Pureish.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Pureish, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'Pureish', 14 | text: 'Pureish', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/TSBigIntKeyword.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSBigIntKeyword, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSBigIntKeyword', 13 | text: 'bigint', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSNumberKeyword.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSNumberKeyword, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSNumberKeyword', 13 | text: 'number', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSObjectKeyword.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSObjectKeyword, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSObjectKeyword', 13 | text: 'object', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSStringKeyword.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSStringKeyword, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSStringKeyword', 13 | text: 'string', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSSymbolKeyword.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSSymbolKeyword, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSSymbolKeyword', 13 | text: 'symbol', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'TSType', 14 | text: 'TSType', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/TemplateLiteral.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TemplateLiteral, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TemplateLiteral', 13 | text: '`...`', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/FlowType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.FlowType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'FlowType', 14 | text: 'FlowType', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/Function.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Function, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'Function', 14 | text: 'Function', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/JSXClosingFragment.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.JSXClosingFragment, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'JSXClosingFragment', 13 | text: '', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/JSXEmptyExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.JSXEmptyExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'JSXEmptyExpression', 13 | text: '{}', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/JSXOpeningFragment.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.JSXOpeningFragment, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'JSXOpeningFragment', 13 | text: '<>', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/Scopable.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Scopable, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'Scopable', 14 | text: 'Scopable', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/TSBooleanKeyword.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSBooleanKeyword, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSBooleanKeyword', 13 | text: 'boolean', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSUnknownKeyword.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSUnknownKeyword, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSUnknownKeyword', 13 | text: 'unknown', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TemplateElement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TemplateElement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TemplateElement', 13 | text: node.value.raw, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/UpdateExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.UpdateExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'UpdateExpression', 13 | text: node.operator, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/Variance.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Variance, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'Variance', 14 | text: 'Variance', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ExportSpecifier.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ExportSpecifier, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ExportSpecifier', 13 | text: 'ExportSpecifier', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/Immutable.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Immutable, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'Immutable', 14 | text: 'Immutable', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/Statement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Statement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'Statement', 14 | text: 'Statement', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/TSEnumMember.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSEnumMember, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSEnumMember', 13 | text: helpers.parse(node.id).text, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSTypeQuery.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSTypeQuery, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSTypeQuery', 13 | text: helpers.parse(node.exprName).text, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSUndefinedKeyword.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSUndefinedKeyword, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSUndefinedKeyword', 13 | text: 'undefined', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TypeAlias.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TypeAlias, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'TypeAlias', 14 | text: 'TypeAlias', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/UnaryLike.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.UnaryLike, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'UnaryLike', 14 | text: 'UnaryLike', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/AwaitExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.AwaitExpression, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | const argument = helpers.parse(node.argument); 10 | return { 11 | type: 'AwaitExpression', 12 | text: `🕒 ${argument.text}`, 13 | ...helpers.normalizeLoc(node.loc), 14 | }; 15 | } 16 | -------------------------------------------------------------------------------- /src/parsers/EnumMember.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.EnumMember, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'EnumMember', 14 | text: 'EnumMember', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/Expression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Expression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'Expression', 14 | text: 'Expression', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ModuleDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ModuleDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ModuleDeclaration', 13 | text: 'ModuleDeclaration', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/ObjectProperty.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ObjectProperty, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ObjectProperty', 13 | text: helpers.parse(node.key).text, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/OpaqueType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.OpaqueType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'OpaqueType', 14 | text: 'OpaqueType', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/RegExpLiteral.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.RegExpLiteral, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'RegExpLiteral', 13 | text: `/${node.pattern}/${node.flags}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/SwitchCase.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.SwitchCase, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'SwitchCase', 13 | text: `case ${helpers.parse(node.test).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSLiteralType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSLiteralType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSLiteralType', 13 | text: helpers.parse(node.literal).text, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/DeclareExportAllDeclaration.ts: -------------------------------------------------------------------------------- 1 | // flow 2 | import T from '@babel/types'; 3 | 4 | import { NormalizedNode, ParserHelpers } from '../types'; 5 | 6 | export default function( 7 | node: T.DeclareExportAllDeclaration, 8 | helpers: ParserHelpers 9 | ): NormalizedNode { 10 | return { 11 | type: 'DeclareExportAllDeclaration', 12 | text: 'DeclareExportAllDeclaration', 13 | ...helpers.normalizeLoc(node.loc), 14 | }; 15 | } 16 | -------------------------------------------------------------------------------- /src/parsers/IfStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.IfStatement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'IfStatement', 13 | text: `if (${helpers.parse(node.test).text})`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/ObjectMember.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ObjectMember, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'ObjectMember', 14 | text: 'ObjectMember', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/PatternLike.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.PatternLike, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'PatternLike', 14 | text: 'PatternLike', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/Placeholder.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Placeholder, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'Placeholder', 14 | text: 'Placeholder', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/RegexLiteral.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.RegexLiteral, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'RegexLiteral', 14 | text: 'RegexLiteral', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/RestElement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.RestElement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'RestElement', 13 | text: `...${helpers.parse(node.argument).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/RestProperty.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.RestProperty, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'RestProperty', 14 | text: 'RestProperty', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/TSArrayType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSArrayType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSArrayType', 13 | text: `${helpers.parse(node.elementType).text}[]`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSEntityName.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSEntityName, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'TSEntityName', 14 | text: 'TSEntityName', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/TSImportType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSImportType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSImportType', 13 | text: `⤺ ${helpers.parse(node.argument).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /demo/mermaidDemo.css: -------------------------------------------------------------------------------- 1 | html { 2 | width: 100%; 3 | } 4 | body { 5 | width: 100%; 6 | height: 100%; 7 | margin: 0; 8 | padding: 0; 9 | font-family: "Source Sans Pro", sans-serif; 10 | font-size: 75%; 11 | background: #fff; 12 | } 13 | svg { 14 | width: 100%; 15 | height: 100%; 16 | } 17 | .node-def > rect { 18 | fill: #a9cffb; 19 | stroke: #3b84a6; 20 | } 21 | .node-branching rect { 22 | fill: #e5fba9; 23 | stroke: #a69b3b; 24 | } 25 | -------------------------------------------------------------------------------- /demo/mermaidDemo.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | Inspector graph 4 | 5 | 6 | 7 | 8 |
9 | 10 | 11 | 12 | -------------------------------------------------------------------------------- /src/parsers/FlowPredicate.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.FlowPredicate, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'FlowPredicate', 14 | text: 'FlowPredicate', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ForXStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ForXStatement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'ForXStatement', 14 | text: 'ForXStatement', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/SpreadElement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.SpreadElement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'SpreadElement', 13 | text: `...${helpers.parse(node.argument).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSRestType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSRestType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSRestType', 13 | text: `...${helpers.parse(node.typeAnnotation).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSTupleType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSTupleType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSTupleType', 13 | text: `[${helpers.parseItems(node.elementTypes)}]`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSTypeElement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSTypeElement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'TSTypeElement', 14 | text: 'TSTypeElement', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/TSTypeLiteral.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSTypeLiteral, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSTypeLiteral', 13 | text: `{${helpers.parseItems(node.members)}}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSTypeReference.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSTypeReference, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSTypeReference', 13 | text: helpers.parse(node.typeName).text, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TypeParameter.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TypeParameter, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'TypeParameter', 14 | text: 'TypeParameter', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /demo/d3Demo.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | Inspector graph 4 | 5 | 6 | 7 | 8 |
9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /src/parsers/EnumNumberBody.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.EnumNumberBody, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'EnumNumberBody', 14 | text: 'EnumNumberBody', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/EnumStringBody.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.EnumStringBody, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'EnumStringBody', 14 | text: 'EnumStringBody', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/EnumSymbolBody.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.EnumSymbolBody, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'EnumSymbolBody', 14 | text: 'EnumSymbolBody', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/FunctionParent.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.FunctionParent, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'FunctionParent', 14 | text: 'FunctionParent', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ImportSpecifier.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ImportSpecifier, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ImportSpecifier', 13 | text: `${helpers.parse(node.imported).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/JSXSpreadChild.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.JSXSpreadChild, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'JSXSpreadChild', 13 | text: `...${helpers.parse(node.expression).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/LabeledStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.LabeledStatement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'LabeledStatement', 13 | text: `${helpers.parse(node.label).text}:`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/PipelineBareFunction.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.PipelineBareFunction, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'PipelineBareFunction', 13 | text: 'PipelineBareFunction', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/ReturnStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ReturnStatement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ReturnStatement', 13 | text: `← ${helpers.parse(node.argument).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/SpreadProperty.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.SpreadProperty, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'SpreadProperty', 14 | text: 'SpreadProperty', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/TSInferType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSInferType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSInferType', 13 | text: `infer ${helpers.parse(node.typeParameter).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/Terminatorless.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Terminatorless, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'Terminatorless', 14 | text: 'Terminatorless', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ThrowStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ThrowStatement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ThrowStatement', 13 | text: `throw ${helpers.parse(node.argument).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'TypeAnnotation', 14 | text: 'TypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/WhileStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.WhileStatement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'WhileStatement', 13 | text: `while(${helpers.parse(node.test).text})`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/CallExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.CallExpression, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'CallExpression', 11 | text: `${helpers.parse(node.callee).text}(${ 12 | node.arguments.length > 0 ? '…' : '' 13 | })`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/EnumDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.EnumDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'EnumDeclaration', 14 | text: 'EnumDeclaration', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/FlowDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.FlowDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'FlowDeclaration', 14 | text: 'FlowDeclaration', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/JSXClosingElement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.JSXClosingElement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'JSXClosingElement', 13 | text: ``, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/ModuleSpecifier.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ModuleSpecifier, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'ModuleSpecifier', 14 | text: 'ModuleSpecifier', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/TSOptionalType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSOptionalType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSOptionalType', 13 | text: `${helpers.parse(node.typeAnnotation).text}?`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSUnionType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSUnionType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSUnionType', 13 | text: helpers.parseItems(node.types, parent, grandParent, ' |'), 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TupleExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TupleExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'TupleExpression', 14 | text: 'TupleExpression', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/WithStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.WithStatement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'WithStatement', 13 | text: `with(${helpers.parse(node.object).text}) { ... }`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/YieldExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.YieldExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'YieldExpression', 13 | text: `yield ${helpers.parse(node.argument).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/EnumBooleanMember.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.EnumBooleanMember, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'EnumBooleanMember', 14 | text: 'EnumBooleanMember', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/EnumNumberMember.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.EnumNumberMember, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'EnumNumberMember', 14 | text: 'EnumNumberMember', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/EnumStringMember.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.EnumStringMember, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'EnumStringMember', 14 | text: 'EnumStringMember', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ExportDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ExportDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'ExportDeclaration', 14 | text: 'ExportDeclaration', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ExpressionStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ExpressionStatement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ExpressionStatement', 13 | text: helpers.parse(node.expression).text, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/ExpressionWrapper.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ExpressionWrapper, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'ExpressionWrapper', 14 | text: 'ExpressionWrapper', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/FunctionTypeParam.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.FunctionTypeParam, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'FunctionTypeParam', 14 | text: 'FunctionTypeParam', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/InferredPredicate.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.InferredPredicate, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'InferredPredicate', 14 | text: 'InferredPredicate', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/InterfaceExtends.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.InterfaceExtends, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'InterfaceExtends', 14 | text: 'InterfaceExtends', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/JSXSpreadAttribute.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.JSXSpreadAttribute, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'JSXSpreadAttribute', 13 | text: `...${helpers.parse(node.argument).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/MemberExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.MemberExpression, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'MemberExpression', 11 | text: `${helpers.parse(node.object).text}.${ 12 | helpers.parse(node.property).text 13 | }`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/ObjectTypeIndexer.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ObjectTypeIndexer, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'ObjectTypeIndexer', 14 | text: 'ObjectTypeIndexer', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/RecordExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.RecordExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'RecordExpression', 14 | text: 'RecordExpression', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/SwitchStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.SwitchStatement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'SwitchStatement', 13 | text: `switch(${helpers.parse(node.discriminant).text}}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSConstructorType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSConstructorType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'TSConstructorType', 14 | text: 'TSConstructorType', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/TSExportAssignment.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSExportAssignment, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSExportAssignment', 13 | text: `↗ ${helpers.parse(node.expression).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSTypeAnnotation', 13 | text: `:${helpers.parse(node.typeAnnotation).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/UnaryExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.UnaryExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'UnaryExpression', 13 | text: node.operator + helpers.parse(node.argument).text, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/UserWhitespacable.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.UserWhitespacable, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'UserWhitespacable', 14 | text: 'UserWhitespacable', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ExportAllDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ExportAllDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ExportAllDeclaration', 13 | text: `↗ ${helpers.parse(node.source).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/FlowBaseAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.FlowBaseAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'FlowBaseAnnotation', 14 | text: 'FlowBaseAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/JSXExpressionContainer.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.JSXExpressionContainer, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'JSXExpressionContainer', 13 | text: helpers.parse(node.expression).text, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/ObjectTypeProperty.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ObjectTypeProperty, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'ObjectTypeProperty', 14 | text: 'ObjectTypeProperty', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/TSNonNullExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSNonNullExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSNonNullExpression', 13 | text: `${helpers.parse(node.expression).text}!`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/ThisTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ThisTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'ThisTypeAnnotation', 14 | text: 'ThisTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/TypeCastExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TypeCastExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'TypeCastExpression', 14 | text: 'TypeCastExpression', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/VoidTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.VoidTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'VoidTypeAnnotation', 14 | text: 'VoidTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/__tests__/code-samples/code12.ts: -------------------------------------------------------------------------------- 1 | const ANSWER = 42; 2 | function test(value, anotherOne, fooBar) { 3 | return value ? ANSWER : null; 4 | } 5 | 6 | function foobar() { 7 | const ANSWER = 100; 8 | const mult = (v) => v * 2; 9 | function sqrtAnd(v) { 10 | return Math.sqrt(v) + ANSWER + test(true); 11 | } 12 | const x = ANSWER * mult(2); 13 | console.log(ANSWER); 14 | } 15 | 16 | if (ANSWER === 42) { 17 | test("no"); 18 | } else { 19 | test("yes"); 20 | } 21 | -------------------------------------------------------------------------------- /src/parsers/AssignmentExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.AssignmentExpression, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | return { 10 | type: 'AssignmentExpression', 11 | left: helpers.parse(node.left).text, 12 | right: helpers.parse(node.right).text, 13 | text: '=', 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/EnumDefaultedMember.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.EnumDefaultedMember, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'EnumDefaultedMember', 14 | text: 'EnumDefaultedMember', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ExportDefaultSpecifier.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ExportDefaultSpecifier, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ExportDefaultSpecifier', 13 | text: `↗ ${helpers.parse(node.exported).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/ExportNamedDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ExportNamedDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ExportNamedDeclaration', 13 | text: helpers.parse(node.declaration).text, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/JSXAttribute.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.JSXAttribute, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'JSXAttribute', 13 | text: `${helpers.parse(node.name).text}=${helpers.parse(node.value).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/MixedTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.MixedTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'MixedTypeAnnotation', 14 | text: 'MixedTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ObjectPattern.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ObjectPattern, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ObjectPattern', 13 | text: `{${node.properties.map(n => helpers.parse(n).text).join(', ')}}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSModuleDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSModuleDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSModuleDeclaration', 13 | text: `declare module ${helpers.parse(node.id).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSParenthesizedType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSParenthesizedType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSParenthesizedType', 13 | text: `(${helpers.parse(node.typeAnnotation).text})`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSTypeOperator.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSTypeOperator, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSTypeOperator', 13 | text: `${node.operator} ${helpers.parse(node.typeAnnotation).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TupleTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TupleTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'TupleTypeAnnotation', 14 | text: 'TupleTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/UnionTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.UnionTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'UnionTypeAnnotation', 14 | text: 'UnionTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ExistsTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ExistsTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'ExistsTypeAnnotation', 14 | text: 'ExistsTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/InterfaceDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.InterfaceDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'InterfaceDeclaration', 14 | text: 'InterfaceDeclaration', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/InterpreterDirective.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.InterpreterDirective, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'InterpreterDirective', 14 | text: 'InterpreterDirective', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/NumberTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.NumberTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'NumberTypeAnnotation', 14 | text: 'NumberTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ObjectTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ObjectTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'ObjectTypeAnnotation', 14 | text: 'ObjectTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ParenthesizedExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ParenthesizedExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ParenthesizedExpression', 13 | text: `(${helpers.parse(node.expression).text})`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/StringTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.StringTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'StringTypeAnnotation', 14 | text: 'StringTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/SymbolTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.SymbolTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'SymbolTypeAnnotation', 14 | text: 'SymbolTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/TSExternalModuleReference.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSExternalModuleReference, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSExternalModuleReference', 13 | text: helpers.parse(node.expression).text, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSInterfaceDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSInterfaceDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSInterfaceDeclaration', 13 | text: `interface ${helpers.parse(node.id).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSIntersectionType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSIntersectionType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSIntersectionType', 13 | text: helpers.parseItems(node.types, parent, grandParent, ' &'), 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TypeofTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TypeofTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'TypeofTypeAnnotation', 14 | text: 'TypeofTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ExportDefaultDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ExportDefaultDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ExportDefaultDeclaration', 13 | text: `↗ ${helpers.parse(node.declaration).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/ExportNamespaceSpecifier.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ExportNamespaceSpecifier, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ExportNamespaceSpecifier', 13 | text: `↗ ${helpers.parse(node.exported).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/FunctionTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.FunctionTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'FunctionTypeAnnotation', 14 | text: 'FunctionTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/GenericTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.GenericTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'GenericTypeAnnotation', 14 | text: 'GenericTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/NullableTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.NullableTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'NullableTypeAnnotation', 14 | text: 'NullableTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ObjectTypeCallProperty.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ObjectTypeCallProperty, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'ObjectTypeCallProperty', 14 | text: 'ObjectTypeCallProperty', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ObjectTypeInternalSlot.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ObjectTypeInternalSlot, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'ObjectTypeInternalSlot', 14 | text: 'ObjectTypeInternalSlot', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/SequenceExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.SequenceExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'SequenceExpression', 13 | text: node.expressions.map(e => helpers.parse(e).text).join(', '), 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TSQualifiedName.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSQualifiedName, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSQualifiedName', 13 | text: `${helpers.parse(node.left).text}.${helpers.parse(node.right).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TaggedTemplateExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TaggedTemplateExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TaggedTemplateExpression', 13 | text: `${helpers.parse(node.tag).text}\`...\``, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/V8IntrinsicIdentifier.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.V8IntrinsicIdentifier, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'V8IntrinsicIdentifier', 14 | text: 'V8IntrinsicIdentifier', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/InterfaceTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.InterfaceTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'InterfaceTypeAnnotation', 14 | text: 'InterfaceTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/PipelineTopicExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.PipelineTopicExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'PipelineTopicExpression', 14 | text: 'PipelineTopicExpression', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/QualifiedTypeIdentifier.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.QualifiedTypeIdentifier, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'QualifiedTypeIdentifier', 14 | text: 'QualifiedTypeIdentifier', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/ObjectTypeSpreadProperty.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ObjectTypeSpreadProperty, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'ObjectTypeSpreadProperty', 14 | text: 'ObjectTypeSpreadProperty', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/TSTypeParameterInstantiation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSTypeParameterInstantiation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSTypeParameterInstantiation', 13 | text: `<${helpers.parseItems(node.params)}>`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/TypeParameterDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TypeParameterDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'TypeParameterDeclaration', 14 | text: 'TypeParameterDeclaration', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/VariableDeclarator.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.VariableDeclarator, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'VariableDeclarator', 13 | text: helpers.parse(node.id).text, 14 | ...helpers.normalizeLoc(node.loc), 15 | meta: helpers.parse(node.id).text, 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/NullLiteralTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.NullLiteralTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'NullLiteralTypeAnnotation', 14 | text: 'NullLiteralTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/TSNamespaceExportDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSNamespaceExportDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSNamespaceExportDeclaration', 13 | text: `↗ as namespace ${helpers.parse(node.id).text}`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/ForInStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ForInStatement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ForInStatement', 13 | text: `${helpers.parse(node.left).text} in ${ 14 | helpers.parse(node.right).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/ForOfStatement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ForOfStatement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ForOfStatement', 13 | text: `${helpers.parse(node.left).text} of ${ 14 | helpers.parse(node.right).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/IntersectionTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.IntersectionTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'IntersectionTypeAnnotation', 14 | text: 'IntersectionTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/NumberLiteralTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.NumberLiteralTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'NumberLiteralTypeAnnotation', 14 | text: 'NumberLiteralTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/StringLiteralTypeAnnotation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.StringLiteralTypeAnnotation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'StringLiteralTypeAnnotation', 14 | text: 'StringLiteralTypeAnnotation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/TypeParameterInstantiation.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TypeParameterInstantiation, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'TypeParameterInstantiation', 14 | text: 'TypeParameterInstantiation', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/TSTypeParameterDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSTypeParameterDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSTypeParameterDeclaration', 13 | text: `<${node.params.map(p => helpers.parse(p).text).join(', ')}>`, 14 | ...helpers.normalizeLoc(node.loc), 15 | }; 16 | } 17 | -------------------------------------------------------------------------------- /src/parsers/PipelinePrimaryTopicReference.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.PipelinePrimaryTopicReference, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | console.log(node); 12 | return { 13 | type: 'PipelinePrimaryTopicReference', 14 | text: 'PipelinePrimaryTopicReference', 15 | ...helpers.normalizeLoc(node.loc), 16 | }; 17 | } 18 | -------------------------------------------------------------------------------- /src/parsers/JSXNamespacedName.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.JSXNamespacedName, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'JSXNamespacedName', 13 | text: `<${helpers.parse(node.namespace).text}:${ 14 | helpers.parse(node.name).text 15 | }>`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/TSAsExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSAsExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSAsExpression', 13 | text: `${helpers.parse(node.expression).text} as ${ 14 | helpers.parse(node.typeAnnotation).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/TSEnumDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSEnumDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSEnumDeclaration', 13 | text: `enum ${helpers.parse(node.id).text} {${helpers.parseItems( 14 | node.members 15 | )}}`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/TSFunctionType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSFunctionType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSFunctionType', 13 | text: `ƒ(${helpers.parseItems(node.parameters)}${ 14 | helpers.parse(node.typeAnnotation).text 15 | })`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/TSMappedType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSMappedType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSMappedType', 13 | text: `{ [${helpers.parse(node.typeParameter).text}]:${ 14 | helpers.parse(node.typeAnnotation).text 15 | } }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/AssignmentPattern.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.AssignmentPattern, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | const left = helpers.parse(node.left).text; 10 | const right = helpers.parse(node.right).text; 11 | return { 12 | type: 'AssignmentPattern', 13 | left, 14 | right, 15 | text: `${left}=${right}`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/ClassProperty.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ClassProperty, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ClassProperty', 13 | text: `${grandParent ? `${helpers.parse(grandParent).text}.` : ''}${ 14 | helpers.parse(node.key).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/JSXMemberExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.JSXMemberExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'JSXMemberExpression', 13 | text: `${helpers.parse(node.object).text}.${ 14 | helpers.parse(node.property).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/TSIndexSignature.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSIndexSignature, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSIndexSignature', 13 | text: `[${helpers.parseItems(node.parameters)}]${ 14 | helpers.parse(node.typeAnnotation).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/TSPropertySignature.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSPropertySignature, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSPropertySignature', 13 | text: `${helpers.parse(node.key).text}${ 14 | helpers.parse(node.typeAnnotation).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/TSTypeAssertion.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSTypeAssertion, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSTypeAssertion', 13 | text: `<${helpers.parse(node.typeAnnotation).text}> ${ 14 | helpers.parse(node.expression).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/TSTypePredicate.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSTypePredicate, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSTypePredicate', 13 | text: `${helpers.parse(node.parameterName).text} is ${ 14 | helpers.parse(node.typeAnnotation).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/BinaryExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.BinaryExpression, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | const l = helpers.parse(node.left).text; 10 | const r = helpers.parse(node.right).text; 11 | return { 12 | type: 'BinaryExpression', 13 | left: l, 14 | right: r, 15 | text: `${l} ${node.operator} ${r}`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/LogicalExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.LogicalExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'LogicalExpression', 13 | text: `${helpers.parse(node.left).text} ${node.operator} ${ 14 | helpers.parse(node.right).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/TSIndexedAccessType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSIndexedAccessType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSIndexedAccessType', 13 | text: `${helpers.parse(node.objectType).text}[${ 14 | helpers.parse(node.indexType).text 15 | }]`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/JSXElement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.JSXElement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'JSXElement', 13 | text: `${helpers.parse(node.openingElement).text}…${ 14 | node.closingElement ? helpers.parse(node.closingElement).text : '' 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/NewExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.NewExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'NewExpression', 13 | text: `new ${helpers.parse(node.callee).text}(${ 14 | node.arguments.length > 0 ? `…${node.arguments.length}` : '' 15 | })`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/TSTypeAliasDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSTypeAliasDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSTypeAliasDeclaration', 13 | text: `${helpers.parse(node.id).text}:${ 14 | helpers.parse(node.typeAnnotation).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/ClassPrivateMethod.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ClassPrivateMethod, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ClassPrivateMethod', 13 | text: `${grandParent ? `${helpers.parse(grandParent).text}.` : ''}${ 14 | helpers.parse(node.key).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/JSXFragment.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.JSXFragment, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'JSXFragment', 13 | text: 14 | helpers.parse(node.openingFragment).text + 15 | (node.closingFragment ? helpers.parse(node.closingFragment).text : ''), 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/OptionalMemberExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.OptionalMemberExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'OptionalMemberExpression', 13 | text: `${helpers.parse(node.object).text}?.${ 14 | helpers.parse(node.property).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/TSParameterProperty.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSParameterProperty, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSParameterProperty', 13 | text: `${node.accessibility ? `${node.accessibility} ` : ''}${ 14 | helpers.parse(node.parameter).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/ClassPrivateProperty.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ClassPrivateProperty, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ClassPrivateProperty', 13 | text: `${grandParent ? `${helpers.parse(grandParent).text}.` : ''}${ 14 | helpers.parse(node.key).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/ImportDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ImportDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ImportDeclaration', 13 | text: `${node.specifiers.map(s => helpers.parse(s).text).join(', ')} ⤺ ${ 14 | helpers.parse(node.source).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/TSImportEqualsDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSImportEqualsDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSImportEqualsDeclaration', 13 | text: `${helpers.parse(node.id).text} ⤺ ${ 14 | helpers.parse(node.moduleReference).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/TSTypeParameter.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSTypeParameter, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | const constrain = node.constraint 12 | ? ` in ${helpers.parse(node.constraint).text}` 13 | : ''; 14 | return { 15 | type: 'TSTypeParameter', 16 | text: node.name + constrain, 17 | ...helpers.normalizeLoc(node.loc), 18 | }; 19 | } 20 | -------------------------------------------------------------------------------- /src/parsers/TSCallSignatureDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSCallSignatureDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSCallSignatureDeclaration', 13 | text: `(${helpers.parseItems(node.parameters)})${ 14 | helpers.parse(node.typeAnnotation).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/OptionalCallExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.OptionalCallExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'OptionalCallExpression', 13 | text: `${helpers.parse(node.callee).text}?.(${ 14 | node.arguments.length > 0 ? `…${node.arguments.length}` : '' 15 | })`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/TSExpressionWithTypeArguments.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSExpressionWithTypeArguments, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSExpressionWithTypeArguments', 13 | text: `${helpers.parse(node.expression).text}${ 14 | helpers.parse(node.typeParameters).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/TSMethodSignature.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSMethodSignature, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSMethodSignature', 13 | text: `${helpers.parse(node.key).text}(${helpers.parseItems( 14 | node.parameters 15 | )})${helpers.parse(node.typeAnnotation).text}`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/ArrayPattern.ts: -------------------------------------------------------------------------------- 1 | import T, { Identifier as IdentifierType } from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | import Identifier from './Identifier'; 5 | 6 | export default function( 7 | node: T.ArrayPattern, 8 | helpers: ParserHelpers 9 | ): NormalizedNode { 10 | return { 11 | type: 'ArrayPattern', 12 | text: `[${node.elements 13 | .map(el => Identifier(el as IdentifierType, helpers)) 14 | .map(n => n.text) 15 | .join(', ')}]`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/ClassBody.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | import * as Traverse from '@babel/traverse'; 3 | 4 | import { NormalizedNode, ParserHelpers } from '../types'; 5 | 6 | export default function( 7 | node: T.ClassBody, 8 | helpers: ParserHelpers, 9 | parent: Traverse.Node 10 | ): NormalizedNode { 11 | let text = '⊏…⊐'; 12 | if (parent && parent.type === 'ClassDeclaration') { 13 | text = `⊏${helpers.parse(parent).text}⊐`; 14 | } 15 | return { 16 | type: 'ClassBody', 17 | text, 18 | ...helpers.normalizeLoc(node.loc), 19 | }; 20 | } 21 | -------------------------------------------------------------------------------- /src/parsers/VariableDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.VariableDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'VariableDeclaration', 13 | text: 14 | node.declarations && node.declarations.length > 0 15 | ? helpers.parse(node.declarations[0]).text 16 | : 'variable', 17 | ...helpers.normalizeLoc(node.loc), 18 | }; 19 | } 20 | -------------------------------------------------------------------------------- /demo/mermaidDemo.js: -------------------------------------------------------------------------------- 1 | window.addEventListener('load', function() { 2 | mermaid.mermaidAPI.initialize({ 3 | startOnLoad: false, 4 | securityLevel: 'loose', 5 | }); 6 | 7 | function draw(graphData) { 8 | const element = document.querySelector('#mermaid'); 9 | const insertSvg = function(svgCode, bindFunctions) { 10 | element.innerHTML = svgCode; 11 | }; 12 | 13 | const graph = mermaid.mermaidAPI.render('graph', graphData, insertSvg); 14 | } 15 | 16 | fetch('./mermaid.graph').then(res => { 17 | res.text().then(draw); 18 | }); 19 | }); 20 | -------------------------------------------------------------------------------- /src/parsers/JSXOpeningElement.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.JSXOpeningElement, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'JSXOpeningElement', 13 | text: `<${helpers.parse(node.name).text}${ 14 | node.attributes.length > 0 ? `…${node.attributes.length}` : '' 15 | }${node.selfClosing ? '/>' : '>'}`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/TSConstructSignatureDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSConstructSignatureDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSConstructSignatureDeclaration', 13 | text: `new (${helpers.parseItems(node.parameters)})${ 14 | helpers.parse(node.typeAnnotation).text 15 | }`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/TSDeclareFunction.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSDeclareFunction, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSDeclareFunction', 13 | text: `declare ${helpers.parse(node.id).text}(${node.params 14 | .map(p => helpers.parse(p).text) 15 | .join(', ')})${helpers.parse(node.returnType).text}`, 16 | ...helpers.normalizeLoc(node.loc), 17 | }; 18 | } 19 | -------------------------------------------------------------------------------- /src/parsers/ImportNamespaceSpecifier.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ImportNamespaceSpecifier, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ImportNamespaceSpecifier', 13 | text: `${helpers.parse(node.local).text}${ 14 | parent && parent.type === 'ImportDeclaration' 15 | ? ` ⤺ ${helpers.parse(parent.source).text}` 16 | : '' 17 | }`, 18 | ...helpers.normalizeLoc(node.loc), 19 | }; 20 | } 21 | -------------------------------------------------------------------------------- /src/parsers/TSConditionalType.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.TSConditionalType, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'TSConditionalType', 13 | text: `${helpers.parse(node.checkType).text} extends ${ 14 | helpers.parse(node.extendsType).text 15 | } ? ${helpers.parse(node.trueType).text} : ${ 16 | helpers.parse(node.falseType).text 17 | }`, 18 | ...helpers.normalizeLoc(node.loc), 19 | }; 20 | } 21 | -------------------------------------------------------------------------------- /src/parsers/FunctionDeclaration.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.FunctionDeclaration, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | const funcName = helpers.parse(node.id).text; 12 | return { 13 | type: 'FunctionDeclaration', 14 | text: `${funcName}${helpers.renderFunctionParameters(node)}`, 15 | ...helpers.normalizeLoc(node.loc), 16 | meta: { 17 | funcName, 18 | params: node.params.map(p => helpers.parse(p).key), 19 | }, 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/__tests__/code-samples/code3.ts: -------------------------------------------------------------------------------- 1 | const ANSWER = 42; 2 | const DATA = [1, 2, 3]; 3 | 4 | function NormalizeBoo(a) { 5 | return a.toUpperCase(); 6 | } 7 | 8 | const somethingElse = (a, b) => { 9 | const answer = getAnswer(() => '300'); 10 | return `the answer is ${answer}`; 11 | }; 12 | 13 | class Moo { 14 | private a = 100; 15 | 16 | public go(c, d) { 17 | const foo = () => { 18 | // comment 19 | }; 20 | function boo() { 21 | const a = 200; 22 | DATA.forEach(v => { 23 | console.log(v); 24 | }); 25 | } 26 | return 'ok'; 27 | } 28 | } 29 | 30 | function boo() { 31 | // a second one 32 | } 33 | -------------------------------------------------------------------------------- /src/parsers/TSDeclareMethod.ts: -------------------------------------------------------------------------------- 1 | /* eslint-disable no-nested-ternary */ 2 | import T from '@babel/types'; 3 | 4 | import { NormalizedNode, ParserHelpers } from '../types'; 5 | 6 | export default function( 7 | node: T.TSDeclareMethod, 8 | helpers: ParserHelpers, 9 | parent: T.Node, 10 | grandParent: T.Node 11 | ): NormalizedNode { 12 | return { 13 | type: 'TSDeclareMethod', 14 | text: `${ 15 | !node.accessibility ? (node.static ? 'static' : '') : node.accessibility 16 | } ${helpers.parse(node.key).text}(${helpers.parseFunctionParameters( 17 | node.params 18 | )})`, 19 | ...helpers.normalizeLoc(node.loc), 20 | }; 21 | } 22 | -------------------------------------------------------------------------------- /src/parsers/ObjectMethod.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ObjectMethod, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | return { 12 | type: 'ObjectMethod', 13 | text: `${helpers.parse(node.key).text}(${ 14 | node.params.length > 0 ? `…${node.params.length}` : '' 15 | })`, 16 | ...helpers.normalizeLoc(node.loc), 17 | meta: { 18 | funcName: helpers.parse(node.key).text, 19 | params: node.params.map(p => helpers.parse(p).key), 20 | }, 21 | }; 22 | } 23 | -------------------------------------------------------------------------------- /src/parsers/ImportDefaultSpecifier.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ImportDefaultSpecifier, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | const imported = helpers.parse(node.local).text; 12 | return { 13 | type: 'ImportDefaultSpecifier', 14 | text: `${imported}${ 15 | parent && parent.type === 'ImportDeclaration' 16 | ? ` ⤺ ${helpers.parse(parent.source).text}` 17 | : '' 18 | }`, 19 | ...helpers.normalizeLoc(node.loc), 20 | meta: imported, 21 | }; 22 | } 23 | -------------------------------------------------------------------------------- /src/parsers/FunctionExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.FunctionExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | let funcName = helpers.parse(node.id).text; 12 | if (funcName === '') { 13 | funcName = 'ƒ'; 14 | } 15 | return { 16 | type: 'FunctionExpression', 17 | text: `${funcName}${helpers.renderFunctionParameters(node)}`, 18 | ...helpers.normalizeLoc(node.loc), 19 | meta: { 20 | funcName, 21 | params: node.params.map(p => helpers.parse(p).key), 22 | }, 23 | }; 24 | } 25 | -------------------------------------------------------------------------------- /src/parsers/ClassMethod.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ClassMethod, 7 | helpers: ParserHelpers, 8 | parent: T.Node | null, 9 | grandParent: T.Node | null 10 | ): NormalizedNode { 11 | return { 12 | type: 'ClassMethod', 13 | text: `${grandParent ? `${helpers.parse(grandParent).text}.` : ''}${ 14 | helpers.parse(node.key).text 15 | }${helpers.renderFunctionParameters(node)}`, 16 | ...helpers.normalizeLoc(node.loc), 17 | meta: { 18 | funcName: helpers.parse(node.key).text, 19 | params: node.params.map(p => helpers.parse(p).key), 20 | }, 21 | }; 22 | } 23 | -------------------------------------------------------------------------------- /src/__tests__/graph.spec.ts: -------------------------------------------------------------------------------- 1 | import fs from "fs"; 2 | import { analyze, graph } from "../index"; 3 | 4 | const JSONFile = `${__dirname}/../../demo/mermaidDemo.json`; 5 | const diagramFile = `${__dirname}/../../demo/mermaid.graph`; 6 | 7 | const code12 = fs 8 | .readFileSync(`${__dirname}/code-samples/code12.ts`) 9 | .toString("utf8"); 10 | 11 | describe("Given the code12.tsx code sample", () => { 12 | describe("when transforming the code to a graph", () => { 13 | it("should return a svg image", () => { 14 | const res = analyze(code12); 15 | // fs.writeFileSync(JSONFile, JSON.stringify(graph.toGraph(res), null, 2)); 16 | fs.writeFileSync(diagramFile, graph.toMermaidDiagram(res)); 17 | }); 18 | }); 19 | }); 20 | -------------------------------------------------------------------------------- /src/__tests__/code5.spec.ts: -------------------------------------------------------------------------------- 1 | import fs from 'fs'; 2 | import { analyze } from '../index'; 3 | 4 | const code5 = fs 5 | .readFileSync(`${__dirname}/code-samples/code5.ts`) 6 | .toString('utf8'); 7 | 8 | describe('Given the code5.tsx code sample', () => { 9 | describe('when analyzing the code', () => { 10 | it('should return all the scope nodes', () => { 11 | const { scopes } = analyze(code5); 12 | const expectation = scopes.map(({ text, type }) => `${type} | ${text}`); 13 | expect(expectation).toStrictEqual([ 14 | 'Program | Program', 15 | 'ArrowFunctionExpression | util()', 16 | 'FunctionDeclaration | doSomething()', 17 | 'ArrowFunctionExpression | new App(…) argument', 18 | ]); 19 | }); 20 | }); 21 | }); 22 | -------------------------------------------------------------------------------- /src/parsers/Identifier.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.Identifier, 7 | helpers: ParserHelpers 8 | ): NormalizedNode { 9 | const typeScriptAnnotation: string = node.typeAnnotation 10 | ? helpers.parse(node.typeAnnotation).text 11 | : ''; 12 | const meta = 13 | typeof node.optional !== 'undefined' && 14 | typeof node.typeAnnotation !== 'undefined' 15 | ? { 16 | isOptional: !!node.optional, 17 | typeAnnotation: helpers.parse(node.typeAnnotation).text, 18 | } 19 | : null; 20 | return { 21 | type: 'Identifier', 22 | text: node.name, 23 | ...helpers.normalizeLoc(node.loc), 24 | meta, 25 | }; 26 | } 27 | -------------------------------------------------------------------------------- /tsconfig.json: -------------------------------------------------------------------------------- 1 | { 2 | "compilerOptions": { 3 | "module": "esnext", 4 | "outDir": "lib/", 5 | "noImplicitAny": true, 6 | "removeComments": true, 7 | "preserveConstEnums": true, 8 | "sourceMap": true, 9 | "target": "ESNext", 10 | "allowJs": true, 11 | "checkJs": false, 12 | "pretty": true, 13 | "skipLibCheck": true, 14 | "strict": true, 15 | "moduleResolution": "node", 16 | "esModuleInterop": true, 17 | "lib": ["dom", "dom.iterable", "ESNext"], 18 | "allowSyntheticDefaultImports": true, 19 | "forceConsistentCasingInFileNames": true, 20 | "resolveJsonModule": true, 21 | "isolatedModules": true, 22 | "strictNullChecks": false 23 | }, 24 | "include": ["src"], 25 | "exclude": ["node_modules", "src/__tests__"] 26 | } -------------------------------------------------------------------------------- /demo/d3Demo.css: -------------------------------------------------------------------------------- 1 | html{ width: 100%; } 2 | body{ 3 | width: 100%; 4 | height: 100%; 5 | margin: 0; 6 | padding: 0; 7 | font-family: 'Source Sans Pro', sans-serif;; 8 | font-size: 75%; 9 | background: #fff; 10 | } 11 | svg { 12 | width: 100%; 13 | height: 100%; 14 | } 15 | .line { 16 | stroke-width: 2px; 17 | } 18 | 19 | .rect-with-text rect { 20 | fill: #e8e8e8; 21 | } 22 | .rect-with-text text { 23 | fill: #000; 24 | cursor: default; 25 | } 26 | 27 | .Program rect { 28 | fill: #0e0909; 29 | } 30 | .Program text { 31 | fill: #fff; 32 | } 33 | 34 | .FunctionDeclaration rect { 35 | fill: #2f6299; 36 | } 37 | .FunctionDeclaration text { 38 | fill: #fff; 39 | } 40 | 41 | .Variable rect { 42 | fill: #90eaaf; 43 | } 44 | .Variable text { 45 | fill: #000; 46 | } -------------------------------------------------------------------------------- /src/__tests__/code7.spec.ts: -------------------------------------------------------------------------------- 1 | import fs from 'fs'; 2 | import { analyze } from '../index'; 3 | 4 | const code7 = fs 5 | .readFileSync(`${__dirname}/code-samples/code7.ts`) 6 | .toString('utf8'); 7 | 8 | describe('Given the code7.tsx code sample', () => { 9 | describe('when analyzing the code', () => { 10 | it('should return all the scope nodes', () => { 11 | const { scopes } = analyze(code7); 12 | const expectation = scopes.map(({ text, type }) => `${type} | ${text}`); 13 | // console.log(JSON.stringify(expectation, null, 2)); 14 | expect(expectation).toStrictEqual([ 15 | 'Program | Program', 16 | 'FunctionDeclaration | parseItems(items, parent, grandParent, delimiter=",")', 17 | 'ArrowFunctionExpression | items.map(…) callback', 18 | ]); 19 | }); 20 | }); 21 | }); 22 | -------------------------------------------------------------------------------- /src/__tests__/code8.spec.ts: -------------------------------------------------------------------------------- 1 | import fs from 'fs'; 2 | import { analyze } from '../index'; 3 | 4 | const code8 = fs 5 | .readFileSync(`${__dirname}/code-samples/code8.jsx`) 6 | .toString('utf8'); 7 | 8 | describe('Given the code8.tsx code sample', () => { 9 | describe('when analyzing the code', () => { 10 | it('should not return duplicated nodes', () => { 11 | const { nodes } = analyze(code8); 12 | const expectation = nodes.map(({ text, type }) => `${type} | ${text}`); 13 | // console.log(JSON.stringify(expectation, null, 2)); 14 | expect(expectation).toStrictEqual([ 15 | 'Program | Program', 16 | 'ImportDeclaration | useState ⤺ "react"', 17 | 'ImportSpecifier | useState', 18 | 'Identifier | useState', 19 | 'StringLiteral | "react"', 20 | ]); 21 | }); 22 | }); 23 | }); 24 | -------------------------------------------------------------------------------- /src/__helpers__/index.ts: -------------------------------------------------------------------------------- 1 | import { NormalizedNode } from '../types'; 2 | import { analyze } from '../index'; 3 | 4 | export function setupTest( 5 | input = '', 6 | type: string, 7 | expectation?: NormalizedNode | 'not-found', 8 | skip = false, 9 | only = false 10 | ) { 11 | (skip ? xdescribe : describe)(`Given ${type} node`, () => { 12 | describe(`when normalizing ${type} the node`, () => { 13 | (only ? fit : it)('should get a proper NormalizedNode object', () => { 14 | const { nodes } = analyze(input); 15 | const found = nodes.find(n => n.type === type); 16 | if (typeof found === 'undefined') { 17 | expect('not-found').toStrictEqual(expectation); 18 | } else { 19 | expect(found).toMatchObject(expectation as Record); 20 | } 21 | }); 22 | }); 23 | }); 24 | } 25 | -------------------------------------------------------------------------------- /node/code-inspector.d.ts: -------------------------------------------------------------------------------- 1 | export interface NormalizedNode { 2 | text: string | number | boolean; 3 | type: string; 4 | key?: string; 5 | parent?: string; 6 | start?: [number | undefined, number | undefined]; 7 | end?: [number | undefined, number | undefined]; 8 | left?: string | number | boolean; 9 | right?: string | number | boolean; 10 | meta?: any; 11 | path?: string; 12 | scopePath?: string; 13 | isScope?: boolean; 14 | variableIdentifier?: string; 15 | children?: NormalizedNode[]; 16 | variables?: NormalizedNode[]; 17 | } 18 | 19 | export interface Analysis { 20 | ast: any; 21 | nodes: NormalizedNode[]; 22 | scopes: NormalizedNode[]; 23 | variables: NormalizedNode[]; 24 | tree: NormalizedNode; 25 | } 26 | 27 | export function analyze(code: string): Analysis; 28 | export function sort(nodes: NormalizedNode[]): NormalizedNode[]; 29 | export function isVariable(node: NormalizedNode): boolean; 30 | -------------------------------------------------------------------------------- /src/types.ts: -------------------------------------------------------------------------------- 1 | export interface NormalizedNode { 2 | text: string | number | boolean; 3 | type: string; 4 | key?: string; 5 | parent?: string; 6 | start?: [number | undefined, number | undefined]; 7 | end?: [number | undefined, number | undefined]; 8 | left?: string | number | boolean; 9 | right?: string | number | boolean; 10 | meta?: any; 11 | path?: string; 12 | scopePath?: string; 13 | isScope?: boolean; 14 | variableIdentifier?: string; 15 | children?: NormalizedNode[]; 16 | variables?: string[]; 17 | } 18 | 19 | export interface Analysis { 20 | ast: any; 21 | nodes: NormalizedNode[]; 22 | scopes: NormalizedNode[]; 23 | variables: NormalizedNode[]; 24 | tree: NormalizedNode; 25 | } 26 | 27 | export type ParserHelpers = { 28 | normalizeLoc: Function; 29 | parse: Function; 30 | parseFunctionParameters: Function; 31 | renderFunctionParameters: Function; 32 | parseItems: Function; 33 | }; 34 | -------------------------------------------------------------------------------- /src/sort.ts: -------------------------------------------------------------------------------- 1 | import { NormalizedNode } from './types'; 2 | 3 | export default function(nodes: NormalizedNode[]): NormalizedNode[] { 4 | const consumed: Record = {}; 5 | // console.log(nodes); 6 | return ( 7 | nodes 8 | // removing duplicates 9 | .filter(node => { 10 | if (!consumed[node.key || '']) { 11 | consumed[node.key || ''] = true; 12 | return true; 13 | } 14 | return false; 15 | }) 16 | // sorting 17 | .sort((a, b) => { 18 | if (a.start[0] === b.start[0]) { 19 | if (a.start[1] > b.start[1]) { 20 | return 1; 21 | } 22 | if (a.start[1] === b.start[1]) { 23 | return a.end[0] > b.end[0] ? -1 : 1; 24 | } 25 | return -1; 26 | } 27 | if (a.start[0] > b.start[0]) { 28 | return 1; 29 | } 30 | return -1; 31 | }) 32 | ); 33 | } 34 | -------------------------------------------------------------------------------- /webpack.node.js: -------------------------------------------------------------------------------- 1 | /* eslint-disable import/no-extraneous-dependencies */ 2 | 3 | const TerserPlugin = require('terser-webpack-plugin'); 4 | const webpack = require('webpack'); 5 | 6 | module.exports = { 7 | entry: ['./src/index.ts'], 8 | module: { 9 | rules: [ 10 | { 11 | test: /\.(js|jsx)$/, 12 | exclude: /node_modules/, 13 | use: ['babel-loader'], 14 | }, 15 | { 16 | test: /\.tsx?$/, 17 | use: 'ts-loader', 18 | exclude: /node_modules/, 19 | }, 20 | ], 21 | }, 22 | resolve: { 23 | extensions: ['.ts', '.js'], 24 | }, 25 | output: { 26 | path: `${__dirname}/node`, 27 | filename: 'code-inspector.js', 28 | libraryTarget: 'commonjs', 29 | }, 30 | optimization: { 31 | minimizer: [new TerserPlugin()], 32 | }, 33 | plugins: [ 34 | new webpack.DefinePlugin({ 35 | __DEV__: true, 36 | }), 37 | ], 38 | performance: { 39 | hints: false, 40 | }, 41 | }; 42 | -------------------------------------------------------------------------------- /webpack.browser.js: -------------------------------------------------------------------------------- 1 | /* eslint-disable import/no-extraneous-dependencies */ 2 | 3 | const TerserPlugin = require('terser-webpack-plugin'); 4 | const webpack = require('webpack'); 5 | 6 | module.exports = { 7 | entry: ['./src/index.ts'], 8 | module: { 9 | rules: [ 10 | { 11 | test: /\.(js|jsx)$/, 12 | exclude: /node_modules/, 13 | use: ['babel-loader'], 14 | }, 15 | { 16 | test: /\.tsx?$/, 17 | use: 'ts-loader', 18 | exclude: /node_modules/, 19 | }, 20 | ], 21 | }, 22 | resolve: { 23 | extensions: ['.ts', '.js'], 24 | }, 25 | output: { 26 | path: `${__dirname}/browser`, 27 | filename: 'code-inspector.js', 28 | library: 'CodeInspector', 29 | libraryTarget: 'umd', 30 | }, 31 | optimization: { 32 | minimizer: [new TerserPlugin()], 33 | }, 34 | plugins: [ 35 | new webpack.DefinePlugin({ 36 | __DEV__: true, 37 | }), 38 | ], 39 | performance: { 40 | hints: false, 41 | }, 42 | }; 43 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 Krasimir Tsonev 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /.eslintrc: -------------------------------------------------------------------------------- 1 | { 2 | "extends": ["prettier"], 3 | "globals": { 4 | "chrome": true, 5 | "d3": true, 6 | "Nodes": true, 7 | "mermaid": true, 8 | "__dirname": true 9 | }, 10 | "rules": { 11 | "no-restricted-globals": 0, 12 | "react/prop-types": 0, 13 | "react/destructuring-assignment": 0, 14 | "no-plusplus": 0, 15 | "react/jsx-filename-extension": 0, 16 | "@typescript-eslint/no-explicit-any": 0, 17 | "@typescript-eslint/explicit-function-return-type": 0, 18 | "@typescript-eslint/no-var-requires": 0, 19 | "import/no-extraneous-dependencies": 0, 20 | "@typescript-eslint/ban-ts-ignore": 0, 21 | "import/no-dynamic-require": 0, 22 | "import/no-cycle": 0, 23 | "no-octal-escape": 0 24 | }, 25 | "settings": { 26 | "import/parsers": { 27 | "@typescript-eslint/parser": [".ts", ".tsx"] 28 | }, 29 | "import/resolver": { 30 | "node": { 31 | "extensions": [".js", ".jsx", ".ts", ".tsx"] 32 | } 33 | } 34 | }, 35 | "parser": "@typescript-eslint/parser", 36 | "plugins": ["@typescript-eslint/eslint-plugin"], 37 | "parserOptions": { 38 | "ecmaVersion": 6, 39 | "sourceType": "module", 40 | "ecmaFeatures": { 41 | "jsx": true 42 | } 43 | } 44 | } 45 | -------------------------------------------------------------------------------- /src/__tests__/code6.spec.ts: -------------------------------------------------------------------------------- 1 | import fs from 'fs'; 2 | import { analyze } from '../index'; 3 | 4 | const code6 = fs 5 | .readFileSync(`${__dirname}/code-samples/code6.jsx`) 6 | .toString('utf8'); 7 | 8 | describe('Given the code6.tsx code sample', () => { 9 | describe('when analyzing the code', () => { 10 | it('should return all the scope nodes', () => { 11 | const { scopes } = analyze(code6); 12 | const expectation = scopes.map(({ text, type }) => `${type} | ${text}`); 13 | expect(expectation).toStrictEqual([ 14 | 'Program | Program', 15 | 'ArrowFunctionExpression | defer(…) callback', 16 | 'ArrowFunctionExpression | progressiveJpg(src)', 17 | 'ArrowFunctionExpression | smallProgressiveJpg(src)', 18 | 'ArrowFunctionExpression | largeProgressiveJpg(src)', 19 | 'ArrowFunctionExpression | LandingPage({content, match, prescreenerType, goToStep, prescreenerLandingPageShown})', 20 | 'ArrowFunctionExpression | useEffect(…) callback', 21 | 'ArrowFunctionExpression | …', 22 | 'ArrowFunctionExpression | Object.keys(…).find(…) callback', 23 | 'ArrowFunctionExpression | mapStateToProps(state, ownProps)', 24 | 'ArrowFunctionExpression | mapDispatchToProps(dispatch)', 25 | 'ArrowFunctionExpression | goToStep: ƒ', 26 | 'ArrowFunctionExpression | prescreenerLandingPageShown: ƒ', 27 | ]); 28 | }); 29 | }); 30 | }); 31 | -------------------------------------------------------------------------------- /src/utils.ts: -------------------------------------------------------------------------------- 1 | import * as Traverse from '@babel/traverse'; 2 | import { SourceLocation } from '@babel/types'; 3 | import { NormalizedNode } from './types'; 4 | 5 | export function normalizeLoc(loc: SourceLocation) { 6 | return { 7 | start: [loc.start.line, loc.start.column + 1], 8 | end: [loc.end.line, loc.end.column + 1], 9 | }; 10 | } 11 | 12 | export function getNodeKey(node: any): string { 13 | const { start, end } = node.loc 14 | ? normalizeLoc(node.loc as SourceLocation) 15 | : { start: [0, 0], end: [0, 0] }; 16 | return `${`${node.type}-${start ? start.join(':') : ''}`}-${ 17 | end ? end.join(':') : '' 18 | }`; 19 | } 20 | 21 | export function getNodePath(node: Traverse.NodePath, path = ''): string { 22 | if (node.parentPath) { 23 | return getNodePath( 24 | node.parentPath, 25 | `${getNodeKey(node.parentPath.node)}${path !== '' ? `.${path}` : ''}` 26 | ); 27 | } 28 | return path; 29 | } 30 | 31 | export function accessNode(nodes: NormalizedNode[]): Function { 32 | const getNodeByKeyCache: Record = {}; 33 | return (key: string): NormalizedNode | undefined => { 34 | if (getNodeByKeyCache[key]) return getNodeByKeyCache[key]; 35 | const found = nodes.find(n => n.key === key); 36 | if (found) { 37 | getNodeByKeyCache[key] = found; 38 | } 39 | return found; 40 | }; 41 | } 42 | 43 | export function pathToTypes(p: string): string[] { 44 | return p.split('.').map(k => k.substr(0, k.indexOf('-'))); 45 | } 46 | -------------------------------------------------------------------------------- /demo/mermaid.graph: -------------------------------------------------------------------------------- 1 | graph TB 2 | Program-1:1-21:1("Program")-->FunctionDeclaration-2:1-4:2("test(value, anotherOne, fooBar)") 3 | FunctionDeclaration-2:1-4:2("test(value, anotherOne, fooBar)")-->ConditionalExpression-3:10-3:31("value?") 4 | Program-1:1-21:1("Program")-->FunctionDeclaration-6:1-14:2("foobar()") 5 | FunctionDeclaration-6:1-14:2("foobar()")-->FunctionDeclaration-9:3-11:4("sqrtAnd(v)") 6 | FunctionDeclaration-9:3-11:4("sqrtAnd(v)")-->CallExpression-10:12-10:24("Math.sqrt(…)") 7 | FunctionDeclaration-9:3-11:4("sqrtAnd(v)")-->CallExpression-10:36-10:46("test(…)") 8 | FunctionDeclaration-6:1-14:2("foobar()")-->CallExpression-12:22-12:29("mult(…)") 9 | FunctionDeclaration-6:1-14:2("foobar()")-->CallExpression-13:3-13:22("console.log(…)") 10 | Program-1:1-21:1("Program")-->IfStatement-16:1-20:2("if (ANSWER === 42)") 11 | Program-1:1-21:1("Program")-->CallExpression-17:3-17:13("test(…)") 12 | Program-1:1-21:1("Program")-->CallExpression-19:3-19:14("test(…)") 13 | class Program-1:1-21:1 node-def 14 | class FunctionDeclaration-2:1-4:2 node-def 15 | class ConditionalExpression-3:10-3:31 node-branching 16 | class FunctionDeclaration-6:1-14:2 node-def 17 | class FunctionDeclaration-9:3-11:4 node-def 18 | class CallExpression-10:12-10:24 node-call 19 | class CallExpression-10:36-10:46 node-call 20 | class CallExpression-12:22-12:29 node-call 21 | class CallExpression-13:3-13:22 node-call 22 | class IfStatement-16:1-20:2 node-branching 23 | class CallExpression-17:3-17:13 node-call 24 | class CallExpression-19:3-19:14 node-call -------------------------------------------------------------------------------- /demo/d3NodeTypes.js: -------------------------------------------------------------------------------- 1 | /* eslint-disable no-fallthrough, no-case-declarations */ 2 | function reactWithText(container, text, fz = 14) { 3 | const r = container 4 | .append('rect') 5 | .attr('width', 10) 6 | .attr('height', 23) 7 | .attr('rx', 3); 8 | const t = container 9 | .append('text') 10 | .text(text) 11 | .attr('font-size', fz); 12 | const textHeight = t.node().parentNode.getBBox().height; 13 | 14 | r.attr('width', t.node().parentNode.getBBox().width + 10); 15 | r.attr('height', textHeight - 10); 16 | r.attr('x', -5); 17 | r.attr('y', -textHeight / 2); 18 | container.attr('class', 'rect-with-text'); 19 | return container; 20 | } 21 | 22 | const Nodes = { 23 | getGraphic(n) { 24 | return n.append('g').each(function(d, i) { 25 | let graphic; 26 | switch (d.type) { 27 | case 'Program': 28 | graphic = reactWithText(d3.select(this), 'program', 20); 29 | break; 30 | case 'FunctionDeclaration': 31 | const scopeDepth = d.scopePath.split('.').length; 32 | graphic = reactWithText( 33 | d3.select(this), 34 | d.meta.funcName, 35 | 10 + 8 / scopeDepth 36 | ); 37 | break; 38 | case 'Identifier': 39 | if (d.isVariable) { 40 | graphic = reactWithText(d3.select(this), d.text); 41 | graphic.attr('class', `${graphic.attr('class')} Variable`); 42 | break; 43 | } 44 | default: 45 | graphic = reactWithText(d3.select(this), d.text, 12); 46 | } 47 | graphic.attr('class', `${graphic.attr('class')} ${d.type}`); 48 | }); 49 | }, 50 | }; 51 | -------------------------------------------------------------------------------- /src/__tests__/code4.spec.ts: -------------------------------------------------------------------------------- 1 | import fs from 'fs'; 2 | import { analyze } from '../index'; 3 | 4 | const code4 = fs 5 | .readFileSync(`${__dirname}/code-samples/code4.tsx`) 6 | .toString('utf8'); 7 | 8 | describe('Given the code4.tsx code sample', () => { 9 | describe('when analyzing the code', () => { 10 | it('should return all the scope nodes', () => { 11 | const { scopes } = analyze(code4); 12 | const expectation = scopes.map(({ text, type }) => `${type} | ${text}`); 13 | expect(expectation).toStrictEqual([ 14 | 'Program | Program', 15 | 'ArrowFunctionExpression | getIcon(type)', 16 | 'FunctionDeclaration | trimText(str, n)', 17 | 'FunctionDeclaration | arrayMove(arr, oldIndex, newIndex)', 18 | 'FunctionDeclaration | createGraphItem(entity, parent)', 19 | 'FunctionDeclaration | addMoreIcon(e)', 20 | 'FunctionDeclaration | decorate()', 21 | 'FunctionDeclaration | setText()', 22 | 'FunctionDeclaration | addBackground()', 23 | 'ArrowFunctionExpression | label.on(…) callback', 24 | 'ArrowFunctionExpression | label.on(…) callback', 25 | 'ObjectMethod | update(…1)', 26 | 'FunctionDeclaration | sortAndPosition()', 27 | 'ArrowFunctionExpression | graph.items.forEach(…) callback', 28 | 'ArrowFunctionExpression | log.forEach(…) callback', 29 | 'FunctionDeclaration | createGraphItems(es, parent)', 30 | 'ArrowFunctionExpression | es.forEach(…) callback', 31 | 'ObjectMethod | entityExists(…1)', 32 | 'ArrowFunctionExpression | this.items.find(…) callback', 33 | 'ObjectMethod | itemPosition(…1)', 34 | 'ArrowFunctionExpression | this.items.findIndex(…) callback', 35 | 'FunctionDeclaration | Graph({entities})', 36 | 'ArrowFunctionExpression | useEffect(…) callback', 37 | ]); 38 | }); 39 | }); 40 | }); 41 | -------------------------------------------------------------------------------- /src/parsers/ArrowFunctionExpression.ts: -------------------------------------------------------------------------------- 1 | import T from '@babel/types'; 2 | 3 | import { NormalizedNode, ParserHelpers } from '../types'; 4 | 5 | export default function( 6 | node: T.ArrowFunctionExpression, 7 | helpers: ParserHelpers, 8 | parent: T.Node, 9 | grandParent: T.Node 10 | ): NormalizedNode { 11 | const meta = { 12 | funcName: 'ƒ', 13 | params: node.params.map(p => helpers.parse(p).key), 14 | }; 15 | if (parent) { 16 | if (parent.type === 'CallExpression') { 17 | return { 18 | type: 'ArrowFunctionExpression', 19 | text: `${helpers.parse(parent).text} callback`, 20 | ...helpers.normalizeLoc(node.loc), 21 | meta, 22 | }; 23 | } 24 | if (parent.type === 'NewExpression') { 25 | return { 26 | type: 'ArrowFunctionExpression', 27 | text: `new ${helpers.parse(parent.callee).text}(…) argument`, 28 | ...helpers.normalizeLoc(node.loc), 29 | meta, 30 | }; 31 | } 32 | if (parent.type === 'VariableDeclarator') { 33 | return { 34 | type: 'ArrowFunctionExpression', 35 | text: `${helpers.parse(parent).text}${helpers.renderFunctionParameters( 36 | node 37 | )}`, 38 | ...helpers.normalizeLoc(node.loc), 39 | meta, 40 | }; 41 | } 42 | if (parent.type === 'ObjectProperty') { 43 | return { 44 | type: 'ArrowFunctionExpression', 45 | text: `${helpers.parse(parent).text}: ƒ`, 46 | ...helpers.normalizeLoc(node.loc), 47 | meta, 48 | }; 49 | } 50 | if (parent.type === 'JSXExpressionContainer') { 51 | return { 52 | type: 'ArrowFunctionExpression', 53 | text: `${helpers.parse(grandParent).text}`, 54 | ...helpers.normalizeLoc(node.loc), 55 | meta, 56 | }; 57 | } 58 | } 59 | return { 60 | type: 'ArrowFunctionExpression', 61 | text: 'ƒ', 62 | ...helpers.normalizeLoc(node.loc), 63 | meta, 64 | }; 65 | } 66 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Logs 2 | logs 3 | *.log 4 | npm-debug.log* 5 | yarn-debug.log* 6 | yarn-error.log* 7 | lerna-debug.log* 8 | 9 | # Diagnostic reports (https://nodejs.org/api/report.html) 10 | report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json 11 | 12 | # Runtime data 13 | pids 14 | *.pid 15 | *.seed 16 | *.pid.lock 17 | 18 | # Directory for instrumented libs generated by jscoverage/JSCover 19 | lib-cov 20 | 21 | # Coverage directory used by tools like istanbul 22 | coverage 23 | *.lcov 24 | 25 | # nyc test coverage 26 | .nyc_output 27 | 28 | # Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files) 29 | .grunt 30 | 31 | # Bower dependency directory (https://bower.io/) 32 | bower_components 33 | 34 | # node-waf configuration 35 | .lock-wscript 36 | 37 | # Compiled binary addons (https://nodejs.org/api/addons.html) 38 | build/Release 39 | 40 | # Dependency directories 41 | node_modules/ 42 | jspm_packages/ 43 | 44 | # TypeScript v1 declaration files 45 | typings/ 46 | 47 | # TypeScript cache 48 | *.tsbuildinfo 49 | 50 | # Optional npm cache directory 51 | .npm 52 | 53 | # Optional eslint cache 54 | .eslintcache 55 | 56 | # Microbundle cache 57 | .rpt2_cache/ 58 | .rts2_cache_cjs/ 59 | .rts2_cache_es/ 60 | .rts2_cache_umd/ 61 | 62 | # Optional REPL history 63 | .node_repl_history 64 | 65 | # Output of 'npm pack' 66 | *.tgz 67 | 68 | # Yarn Integrity file 69 | .yarn-integrity 70 | 71 | # dotenv environment variables file 72 | .env 73 | .env.test 74 | 75 | # parcel-bundler cache (https://parceljs.org/) 76 | .cache 77 | 78 | # Next.js build output 79 | .next 80 | 81 | # Nuxt.js build / generate output 82 | .nuxt 83 | 84 | # Gatsby files 85 | .cache/ 86 | # Comment in the public line in if your project uses Gatsby and *not* Next.js 87 | # https://nextjs.org/blog/next-9-1#public-directory-support 88 | # public 89 | 90 | # vuepress build output 91 | .vuepress/dist 92 | 93 | # Serverless directories 94 | .serverless/ 95 | 96 | # FuseBox cache 97 | .fusebox/ 98 | 99 | # DynamoDB Local files 100 | .dynamodb/ 101 | 102 | # TernJS port file 103 | .tern-port 104 | -------------------------------------------------------------------------------- /src/parse.ts: -------------------------------------------------------------------------------- 1 | /* eslint-disable global-require, @typescript-eslint/no-use-before-define */ 2 | import * as Traverse from '@babel/traverse'; 3 | import { NormalizedNode } from './types'; 4 | import { getNodeKey, normalizeLoc } from './utils'; 5 | 6 | import Parsers from './parsers'; 7 | 8 | function parseFunctionParameters(params: any[]): string { 9 | if (params.length > 0) { 10 | return `…${params.length}`; 11 | } 12 | return ''; 13 | } 14 | 15 | function renderFunctionParameters( 16 | node: any, 17 | parent: Traverse.Node, 18 | grandParent: Traverse.Node, 19 | delimiter = ',' 20 | ): string { 21 | if (node.params && node.params.length > 0) { 22 | return `(${parseItems(node.params, parent, grandParent, delimiter)})`; 23 | } 24 | return '()'; 25 | } 26 | 27 | function parseItems( 28 | items: any[], 29 | parent: Traverse.Node, 30 | grandParent: Traverse.Node, 31 | delimiter = ',' 32 | ): string { 33 | if (items.length > 0) { 34 | return items 35 | .map(i => parse(i, parent, grandParent).text) 36 | .join(`${delimiter} `); 37 | } 38 | return ''; 39 | } 40 | 41 | export function parse( 42 | node: Traverse.Node | undefined, 43 | parent: Traverse.Node | null, 44 | grandParent: Traverse.Node | null 45 | ): NormalizedNode { 46 | if (node && Parsers[node.type]) { 47 | const normalizedNode = Parsers[node.type]( 48 | node, 49 | { 50 | normalizeLoc, 51 | parse, 52 | parseFunctionParameters, 53 | parseItems, 54 | renderFunctionParameters, 55 | }, 56 | parent, 57 | grandParent 58 | ); 59 | normalizedNode.key = getNodeKey(node); 60 | if (parent) normalizedNode.parent = getNodeKey(parent); 61 | 62 | return normalizedNode; 63 | } 64 | if (node && node.type) { 65 | return { 66 | key: node.type, 67 | text: node.type, 68 | type: node.type, 69 | }; 70 | } 71 | return { 72 | key: 'Unknown', 73 | text: '', 74 | type: 'Unknown', 75 | }; 76 | } 77 | 78 | export function unknownNormalizedNode(): NormalizedNode { 79 | return { 80 | key: 'Unknown', 81 | text: 'Unknown', 82 | type: 'Unknown', 83 | }; 84 | } 85 | -------------------------------------------------------------------------------- /scripts/generate.js: -------------------------------------------------------------------------------- 1 | /* eslint-disable prettier/prettier */ 2 | const fs = require('fs'); 3 | 4 | const root = `${__dirname}/../src/`; 5 | const types = require(`${__dirname}/../src/types.json`); 6 | 7 | function getCode(type) { 8 | return `import T from '@babel/types'; 9 | 10 | import { NormalizedNode, ParserHelpers } from '../types'; 11 | 12 | export default function( 13 | node: T.${type}, 14 | helpers: ParserHelpers, 15 | parent: T.Node, 16 | grandParent: T.Node 17 | ): NormalizedNode { 18 | console.log(node); 19 | return { 20 | type: '${type}', 21 | text: '${type}', 22 | ...helpers.normalizeLoc(node.loc), 23 | }; 24 | } 25 | `; 26 | } 27 | 28 | function getTestCode(type) { 29 | return `setupTest( 30 | \` 31 | 32 | \`, 33 | '${type}', 34 | undefined, 35 | true 36 | ); 37 | `; 38 | } 39 | 40 | console.log('-----------------------'); 41 | 42 | const parsersCode = `/* eslint-disable prettier/prettier */ 43 | // !!! 44 | // This file is auto generated. Do not modify it manually. 45 | // Check out scripts/generate.js file 46 | 47 | ${types.map(type => `import ${type} from './${type}';`).join('\n')} 48 | 49 | const parsers: Record = { 50 | ${types.map(type => type).join(',\n ')} 51 | } 52 | export default parsers; 53 | `; 54 | fs.writeFileSync(`${root}parsers/index.ts`, parsersCode); 55 | console.log(`parsers/index.ts saved`); 56 | 57 | let totalFilesCreated = 0; 58 | let tests = `import { setupTest } from '../__helpers__';\n\n`; 59 | 60 | types.forEach(type => { 61 | if (type !== '') { 62 | const file = `${root}parsers/${type}.ts`; 63 | if (!fs.existsSync(file)) { 64 | fs.writeFileSync(file, getCode(type)); 65 | console.log(`${type}.ts created`); 66 | totalFilesCreated += 1; 67 | } 68 | tests += `${getTestCode(type) }\n`; 69 | } 70 | }); 71 | 72 | if (!fs.existsSync(`${root}__tests__/nodes.spec.ts`)) { 73 | fs.writeFileSync(`${root}__tests__/nodes.spec.ts`, tests); 74 | console.log(`__tests__/nodes.spec.ts created`); 75 | totalFilesCreated += 1; 76 | } 77 | 78 | console.log('-----------------------'); 79 | console.log(`${totalFilesCreated} files created`); 80 | console.log('-----------------------'); 81 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "code-inspector", 3 | "version": "1.16.0", 4 | "main": "node/code-inspector.js", 5 | "description": "Static analysis for your code", 6 | "devDependencies": { 7 | "@babel/core": "7.5.0", 8 | "@babel/parser": "7.8.8", 9 | "@babel/plugin-transform-regenerator": "7.4.5", 10 | "@babel/plugin-transform-runtime": "7.5.0", 11 | "@babel/preset-env": "7.5.0", 12 | "@babel/preset-typescript": "7.8.3", 13 | "@babel/runtime": "7.5.0", 14 | "@babel/traverse": "7.9.0", 15 | "@babel/types": "7.9.0", 16 | "@jest/console": "25.1.0", 17 | "@types/jest": "25.1.4", 18 | "@types/lodash": "4.14.149", 19 | "@types/node": "13.9.1", 20 | "@types/webpack-env": "1.15.1", 21 | "@typescript-eslint/eslint-plugin": "2.19.2", 22 | "@typescript-eslint/parser": "2.19.2", 23 | "ast-types": "0.13.2", 24 | "babel-eslint": "9.0.0", 25 | "babel-jest": "25.1.0", 26 | "babel-loader": "8.0.4", 27 | "clipboardy": "2.3.0", 28 | "eslint": "5.16.0", 29 | "eslint-config-prettier": "6.11.0", 30 | "eslint-plugin-html": "5.0.5", 31 | "eslint-plugin-import": "2.20.0", 32 | "eslint-plugin-jsx-a11y": "6.2.3", 33 | "eslint-plugin-react": "7.18.0", 34 | "eslint-plugin-react-hooks": "1.7.0", 35 | "jest": "25.1.0", 36 | "prettier": "1.19.1", 37 | "regenerator-runtime": "0.13.2", 38 | "terser-webpack-plugin": "1.2.3", 39 | "ts-loader": "6.2.1", 40 | "typescript": "3.7.5", 41 | "webpack": "4.41.6", 42 | "webpack-cli": "3.1.2" 43 | }, 44 | "scripts": { 45 | "build": "webpack --config ./webpack.browser.js --mode production && webpack --config ./webpack.node.js --mode production", 46 | "dev": "webpack --config ./webpack.browser.js --watch --mode development", 47 | "test": "./node_modules/.bin/jest ./src/__tests__/*.spec.ts", 48 | "test-watch": "./node_modules/.bin/jest ./src/__tests__/*.spec.ts --watch", 49 | "release": "yarn test && yarn build", 50 | "generate": "node ./scripts/generate.js" 51 | }, 52 | "repository": { 53 | "type": "git", 54 | "url": "git+https://github.com/krasimir/code-inspector.git" 55 | }, 56 | "keywords": [ 57 | "static", 58 | "analysis", 59 | "code", 60 | "ast", 61 | "scope", 62 | "inspector", 63 | "metaprogramming" 64 | ], 65 | "author": "Krasimir Tsonev", 66 | "license": "MIT", 67 | "jest": { 68 | "setupFilesAfterEnv": [ 69 | "./jest/index.ts" 70 | ], 71 | "verbose": false, 72 | "globals": {}, 73 | "watchPathIgnorePatterns": [ 74 | "/demo/" 75 | ] 76 | }, 77 | "dependencies": {} 78 | } 79 | -------------------------------------------------------------------------------- /src/__tests__/code-samples/code13.ts: -------------------------------------------------------------------------------- 1 | /* eslint-disable max-len */ 2 | import React from 'react'; 3 | import Helmet from 'react-helmet'; 4 | import styled, { keyframes } from 'styled-components'; 5 | import { connect } from 'react-redux'; 6 | import PropTypes from 'prop-types'; 7 | 8 | import BrandBar from 'calpamos/src/ui/BrandBar.jsx'; 9 | import theme from 'calpamos/src/theme'; 10 | import { Box, Text, Title, ExternalLink, Image } from 'calpamos/src/ui/primitives'; 11 | import { Container, Row, Col } from 'calpamos/src/ui/grid'; 12 | import { getContentOfType } from 'calpamos/src/content/selectors'; 13 | import { useCoBrandedHeader } from 'calpamos/src/whitelabel'; 14 | 15 | import withPrescreenerType from '../utils/withPrescreenerType'; 16 | import PrescreenerBrandBar from './PrescreenerBrandBar.jsx'; 17 | 18 | const { colors } = theme; 19 | 20 | const popKeyframes = keyframes` 21 | 0% { transform: scale(0.25); opacity: 0 } 22 | 10% { transform: scale(1.25); opacity: 0.75 } 23 | 20% { transform: scale(1); opacity: 1 } 24 | 90% { transform: scale(1); } 25 | 95% { transform: scale(1.25); } 26 | 100% { transform: scale(1); } 27 | `; 28 | 29 | const IconWrapper = styled(Box).attrs({ 30 | display: 'inline-block', 31 | height: '32px', 32 | p: 4, 33 | position: 'relative', 34 | mr: 4, 35 | width: '32px' 36 | })` 37 | vertical-align: middle; 38 | `; 39 | 40 | const Icon = styled(Image).attrs({ 41 | color: 'white', 42 | is: 'svg', 43 | position: 'absolute', 44 | top: 0, 45 | bottom: 0, 46 | left: 0, 47 | right: 0, 48 | m: 'auto' 49 | })` 50 | animation: ${popKeyframes} 3s linear forwards; 51 | animation-delay: 150ms; 52 | `; 53 | 54 | const PageTitle = styled(Title).attrs({ 55 | display: 'inline-block', 56 | small: true 57 | })` 58 | vertical-align: middle; 59 | `; 60 | 61 | function Error({ content }) { 62 | return ( 63 | 64 | 65 | Antidote 66 | 67 | {useCoBrandedHeader(content.whitelabelConfiguration) ? : } 68 | 69 | 70 | 71 | 72 | 73 | 74 | 78 | 79 | 80 | Oops, something’s gone wrong! 81 | 82 | Please wait five to ten minutes and go back. 83 | 84 | 85 | 86 | 87 | 88 | ); 89 | } 90 | 91 | Error.propTypes = { 92 | content: PropTypes.object.isRequired 93 | }; 94 | 95 | const mapStateToProps = (state, ownProps) => ({ 96 | content: getContentOfType(state, ownProps.prescreenerType) 97 | }); 98 | 99 | export default withPrescreenerType(connect(mapStateToProps)(Error)); -------------------------------------------------------------------------------- /src/graph.ts: -------------------------------------------------------------------------------- 1 | /* eslint-disable no-param-reassign, @typescript-eslint/no-use-before-define, @typescript-eslint/no-empty-function */ 2 | import uniq from "lodash/uniq"; 3 | import get from "lodash/get"; 4 | import { NormalizedNode, Analysis } from "./types"; 5 | import { accessNode } from "./utils"; 6 | import { NODES_FUNCTION_SCOPES, NODES_DEFINING_SCOPES } from "./constants"; 7 | 8 | interface GraphLink { 9 | source: string; 10 | target: string; 11 | type?: string; 12 | } 13 | 14 | const SCOPES_TO_ADD: Record = { 15 | FunctionDeclaration: true, 16 | FunctionExpression: true, 17 | ClassMethod: true, 18 | ObjectMethod: true, 19 | ClassDeclaration: true, 20 | }; 21 | 22 | const BRANCHING: Record = { 23 | ConditionalExpression: true, 24 | IfStatement: true, 25 | }; 26 | 27 | const EXECUTION: Record = { 28 | CallExpression: true, 29 | }; 30 | 31 | function toGraph( 32 | analysis: Analysis 33 | ): { nodes: NormalizedNode[]; links: GraphLink[] } { 34 | const { nodes, variables, tree } = analysis; 35 | const nodesData: NormalizedNode[] = []; 36 | const linksData: GraphLink[] = []; 37 | 38 | function addNodeToGraph(node: NormalizedNode) { 39 | if (!nodesData.find(({ key }) => key === node.key)) { 40 | nodesData.push(node); 41 | } 42 | } 43 | function linkNodes() { 44 | for (let i = 0; i < nodesData.length; i++) { 45 | const node = nodesData[i]; 46 | const scope = node.scopePath.split(".").pop(); 47 | console.log(scope); 48 | } 49 | } 50 | function process(node: NormalizedNode) { 51 | if ( 52 | SCOPES_TO_ADD[node.type] || 53 | BRANCHING[node.type] || 54 | EXECUTION[node.type] 55 | ) { 56 | addNodeToGraph(node); 57 | } 58 | if (node.children) { 59 | node.children.forEach((c) => { 60 | process(c); 61 | }); 62 | } 63 | } 64 | 65 | process(tree); 66 | linkNodes(); 67 | 68 | return { nodes: nodesData, links: linksData }; 69 | } 70 | 71 | function toMermaidDiagram(analysis: Analysis): string { 72 | const { nodes, links } = toGraph(analysis); 73 | const getNodeByKey = accessNode(analysis.nodes); 74 | const diagram: string[] = [`graph TB`]; 75 | const styles: Record = {}; 76 | 77 | function addNode(n: NormalizedNode): string { 78 | let str = n.key; 79 | if (BRANCHING[n.type]) { 80 | str += `("${n.text}")`; 81 | styles[n.key] = "node-branching"; 82 | } else if (EXECUTION[n.type]) { 83 | str += `("${n.text}")`; 84 | styles[n.key] = "node-call"; 85 | } else { 86 | str += `("${n.text}")`; 87 | styles[n.key] = "node-def"; 88 | } 89 | return str; 90 | } 91 | function addLink(A: NormalizedNode, B: NormalizedNode) { 92 | diagram.push(`${addNode(A)}-->${addNode(B)}`); 93 | } 94 | 95 | nodes.forEach((node) => { 96 | const scopePath = node.scopePath.split(".").reverse(); 97 | let found = false; 98 | for (let i = 0; i < scopePath.length; i++) { 99 | const foundScope = nodes.find((n) => n.key === scopePath[i]); 100 | if (foundScope) { 101 | addLink(foundScope, node); 102 | found = true; 103 | break; 104 | } 105 | } 106 | if (!found) { 107 | const root = getNodeByKey(scopePath[scopePath.length - 1]); 108 | if (root && root.type === "Program") { 109 | addLink(root, node); 110 | } 111 | } 112 | }); 113 | 114 | // styles 115 | 116 | return diagram 117 | .concat( 118 | Object.keys(styles).map((key) => { 119 | return `class ${key} ${styles[key]}`; 120 | }) 121 | ) 122 | .join("\n"); 123 | } 124 | 125 | const graphAPI = { 126 | toGraph, 127 | toMermaidDiagram, 128 | }; 129 | 130 | export default graphAPI; 131 | 132 | /* 133 | graph TB 134 | A --- B 135 | B-->C[fa:fa-ban forbidden] 136 | B-->D(fa:fa-spinner) 137 | E --- X 138 | */ 139 | -------------------------------------------------------------------------------- /src/__tests__/code-samples/code.ts: -------------------------------------------------------------------------------- 1 | export default from "bar"; 2 | export const a = {}; 3 | const b = 42; 4 | export default b; 5 | 6 | function f(j, k){ 7 | "use strict".foo; 8 | } 9 | 10 | for(var i=0; i<10; i++) { 11 | console.log(i); 12 | } 13 | for(var c in d) { 14 | console.log(a); 15 | } 16 | 17 | (function (w) { 18 | return function fn(op) {} /42/i 19 | })(window) 20 | 21 | const Comp = function () { 22 | return ( 23 | 24 | { 25 | () =>

Hello

26 | } 27 | 28 | <> 29 | Hello 30 | 31 | {} 32 | 33 | ) 34 | } 35 | 36 | if (a === 'foo' && x || y || z) { 37 | console.log('a is foo'); 38 | } 39 | 40 | const cxc = new CCC('foo', 'bar'); 41 | const nnn = null; 42 | 43 | var obob = { 44 | foo: 'bar', 45 | mmm(a) { 46 | return a + 1; 47 | } 48 | } 49 | const { foo, mmm } = obob; 50 | 51 | function * TTT() { 52 | if ((yield select(mySelector))) { 53 | return 'aaa'; 54 | } 55 | } 56 | 57 | class A { 58 | #a: string; 59 | #b?; 60 | #c?: number; 61 | #d!; 62 | #e!: boolean; 63 | } 64 | 65 | const eee = /foo bar/g; 66 | 67 | function MyFunc(a, b, ...re) { 68 | return { 69 | ...re 70 | } 71 | } 72 | 73 | function aIO({ b, ...c }) {} 74 | 75 | const moo = (a(), b()); 76 | 77 | class M extends TT { 78 | constructor() { 79 | super('aa') 80 | } 81 | } 82 | 83 | switch(SOME) { 84 | case 'foo': console.log('aaa'); break; 85 | } 86 | 87 | function UI(a: any):void {} 88 | var tsa: number[] = []; 89 | 90 | tsa(a as Object) 91 | 92 | let appp: any; 93 | let un: unknown; 94 | let bnnnn: boolean; 95 | let ne: never; 96 | let nul: null; 97 | let num: number; 98 | let o: object; 99 | let st: string; 100 | let sy: symbol; 101 | let u: undefined; 102 | let v: void; 103 | let n: bigint; 104 | 105 | interface I { 106 | (x: number, b: string): void; 107 | } 108 | 109 | let x: number extends string ? boolean : null; 110 | 111 | interface II { 112 | new (x: number): void; 113 | } 114 | 115 | declare function f(a:number): void; 116 | declare function f(): T; 117 | 118 | class C { 119 | static f(a:string, b: string); 120 | public static f(a:string, b: string); 121 | protected static f(a:string, b: string); 122 | private static f(a:string, b: string); 123 | } 124 | 125 | const enum Foo1 { 126 | "OP"= "HOP" 127 | } 128 | 129 | enum A90 { 130 | a, 131 | "r" 132 | } 133 | 134 | export = f; 135 | 136 | (class C implements X.Y {}); 137 | 138 | import xxff = require ("asdfasdf"); 139 | 140 | type MyType = ({ theme }: any) => any; 141 | 142 | let opi: typeof import('./x'); 143 | 144 | class FF2C { 145 | [x: string]: any; 146 | readonly [x: string]: any; 147 | } 148 | 149 | let x90: T[K]; 150 | 151 | type Element = T extends (infer U)[] ? U : T; 152 | 153 | type F10 = x90 & Element; 154 | 155 | type Foo12 = false; 156 | 157 | let map1: { [P in string]: number; }; 158 | 159 | interface I892 { 160 | [Symbol.iterator](): void; 161 | [Symbol.iterator]?(): number; 162 | } 163 | 164 | declare module "m" {} 165 | 166 | export as namespace A; 167 | 168 | x!; 169 | 170 | let go22: [string, number?, (string | number)?] 171 | 172 | class C221 { 173 | constructor( 174 | public y?: number = 0 175 | ) {} 176 | } 177 | 178 | interface Comma { x: number, y: number } 179 | 180 | let x123: [string, ...string[],] 181 | 182 | class F3oo { 183 | isBar(): this is string { 184 | } 185 | isBaz = (): this is string => { 186 | } 187 | } 188 | 189 | const s = { 190 | set m(this: { x: number }, value) {} 191 | }; 192 | 193 | let x76: keyof T; 194 | 195 | raw`token ${`nested ${`deeply` + {}} blah`}` 196 | 197 | class Foo1920 { 198 | method() { 199 | this.go(); 200 | } 201 | } 202 | 203 | throw ui89; 204 | 205 | try { 206 | throw new Error('foo'); 207 | } catch(err) { 208 | console.log(err); 209 | } 210 | 211 | let a786: any; 212 | 213 | -x675 214 | 215 | while (true) { } 216 | 217 | with (x4590d) { 218 | foo = bar 219 | } --------------------------------------------------------------------------------