@proteinjs/reflection-build 1.0.2 → 1.0.4

package/dist/modules/typescript-parser/imports/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./ExternalModuleImport"), exports);
+tslib_1.__exportStar(require("./Import"), exports);
+tslib_1.__exportStar(require("./NamedImport"), exports);
+tslib_1.__exportStar(require("./NamespaceImport"), exports);
+tslib_1.__exportStar(require("./StringImport"), exports);

package/dist/modules/typescript-parser/index.d.ts

@@ -0,0 +1,12 @@
+export * from './TypescriptParser';
+export * from './Node';
+export * from './SymbolSpecifier';
+export * from './DeclarationIndex';
+export * from './code-generators/TypescriptGenerationOptions';
+export * from './code-generators/TypescriptCodeGenerator';
+export * from './declarations';
+export * from './exports';
+export * from './imports';
+export * from './resources';
+export * from './type-guards/TypescriptHeroGuards';
+export { Type, TypeAlias } from './node-parser/changes/parseType';

package/dist/modules/typescript-parser/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./TypescriptParser"), exports);
+tslib_1.__exportStar(require("./Node"), exports);
+tslib_1.__exportStar(require("./SymbolSpecifier"), exports);
+tslib_1.__exportStar(require("./DeclarationIndex"), exports);
+tslib_1.__exportStar(require("./code-generators/TypescriptGenerationOptions"), exports);
+tslib_1.__exportStar(require("./code-generators/TypescriptCodeGenerator"), exports);
+tslib_1.__exportStar(require("./declarations"), exports);
+tslib_1.__exportStar(require("./exports"), exports);
+tslib_1.__exportStar(require("./imports"), exports);
+tslib_1.__exportStar(require("./resources"), exports);
+tslib_1.__exportStar(require("./type-guards/TypescriptHeroGuards"), exports);

package/dist/modules/typescript-parser/node-parser/changes/parseType.d.ts

@@ -0,0 +1,14 @@
+import { TypeAliasDeclaration, VariableDeclaration } from 'typescript';
+export declare type TypeAlias = {
+    name: string;
+    typeParameters: string[];
+};
+export declare type Type = {
+    text: string;
+    parentTypes: TypeAlias[];
+};
+export declare function parseType(declaration: VariableDeclaration | TypeAliasDeclaration): Type;
+export declare function parseTypeAndParameters(expression: string): {
+    name: string;
+    typeParameters: string[];
+};

package/dist/modules/typescript-parser/node-parser/changes/parseType.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTypeAndParameters = exports.parseType = void 0;
+function parseType(declaration) {
+    const typeText = declaration.type ? declaration.type.getText() : null;
+    if (!typeText)
+        return { text: '', parentTypes: [] };
+    const serializedChildTypes = typeText.split('&');
+    const parentTypes = [];
+    for (const serializedChildType of serializedChildTypes) {
+        let name = serializedChildType.trim();
+        let typeParameters = [];
+        if (name.startsWith('{')) {
+            parentTypes.push({ name, typeParameters });
+            continue;
+        }
+        parentTypes.push(parseTypeAndParameters(name));
+    }
+    return { text: typeText, parentTypes: parentTypes };
+}
+exports.parseType = parseType;
+function parseTypeAndParameters(expression) {
+    let name = expression.trim();
+    let typeParameters = [];
+    if (name.includes('<')) {
+        typeParameters = parseTypeParameters(name);
+        name = name.slice(0, name.indexOf('<'));
+    }
+    return { name, typeParameters };
+}
+exports.parseTypeAndParameters = parseTypeAndParameters;
+function parseTypeParameters(typeParameterExpression) {
+    let serialiedTypeParameters = typeParameterExpression.slice(typeParameterExpression.indexOf('<') + 1, typeParameterExpression.length - 1);
+    return serialiedTypeParameters.split(',').map((typeParameter) => typeParameter.trim());
+}

package/dist/modules/typescript-parser/node-parser/class-parser.d.ts

@@ -0,0 +1,30 @@
+import { ClassDeclaration, ConstructorDeclaration, Node } from 'typescript';
+import { ClassDeclaration as TshClass } from '../declarations/ClassDeclaration';
+import { ConstructorDeclaration as TshConstructor } from '../declarations/ConstructorDeclaration';
+import { Resource } from '../resources/Resource';
+/**
+ * Parses the identifiers of a class (usages).
+ *
+ * @export
+ * @param {Resource} tsResource
+ * @param {Node} node
+ */
+export declare function parseClassIdentifiers(tsResource: Resource, node: Node): void;
+/**
+ * Parse information about a constructor. Contains parameters and used modifiers
+ * (i.e. constructor(private name: string)).
+ *
+ * @export
+ * @param {TshClass} parent
+ * @param {TshConstructor} ctor
+ * @param {ConstructorDeclaration} node
+ */
+export declare function parseCtorParams(parent: TshClass, ctor: TshConstructor, node: ConstructorDeclaration): void;
+/**
+ * Parses a class node into its declaration. Calculates the properties, constructors and methods of the class.
+ *
+ * @export
+ * @param {Resource} tsResource
+ * @param {ClassDeclaration} node
+ */
+export declare function parseClass(tsResource: Resource, node: ClassDeclaration): void;

package/dist/modules/typescript-parser/node-parser/class-parser.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseClass = exports.parseCtorParams = exports.parseClassIdentifiers = void 0;
+const typescript_1 = require("typescript");
+const AccessorDeclaration_1 = require("../declarations/AccessorDeclaration");
+const ClassDeclaration_1 = require("../declarations/ClassDeclaration");
+const ConstructorDeclaration_1 = require("../declarations/ConstructorDeclaration");
+const DefaultDeclaration_1 = require("../declarations/DefaultDeclaration");
+const MethodDeclaration_1 = require("../declarations/MethodDeclaration");
+const ParameterDeclaration_1 = require("../declarations/ParameterDeclaration");
+const PropertyDeclaration_1 = require("../declarations/PropertyDeclaration");
+const TypescriptGuards_1 = require("../type-guards/TypescriptGuards");
+const function_parser_1 = require("./function-parser");
+const identifier_parser_1 = require("./identifier-parser");
+const parse_utilities_1 = require("./parse-utilities");
+const parseType_1 = require("./changes/parseType");
+/**
+ * Parses the identifiers of a class (usages).
+ *
+ * @export
+ * @param {Resource} tsResource
+ * @param {Node} node
+ */
+function parseClassIdentifiers(tsResource, node) {
+    for (const child of node.getChildren()) {
+        switch (child.kind) {
+            case typescript_1.SyntaxKind.Identifier:
+                identifier_parser_1.parseIdentifier(tsResource, child);
+                break;
+            default:
+                break;
+        }
+        parseClassIdentifiers(tsResource, child);
+    }
+}
+exports.parseClassIdentifiers = parseClassIdentifiers;
+/**
+ * Parse information about a constructor. Contains parameters and used modifiers
+ * (i.e. constructor(private name: string)).
+ *
+ * @export
+ * @param {TshClass} parent
+ * @param {TshConstructor} ctor
+ * @param {ConstructorDeclaration} node
+ */
+function parseCtorParams(parent, ctor, node) {
+    if (!node.parameters) {
+        return;
+    }
+    node.parameters.forEach((o) => {
+        if (TypescriptGuards_1.isIdentifier(o.name)) {
+            ctor.parameters.push(new ParameterDeclaration_1.ParameterDeclaration(o.name.text, parse_utilities_1.getNodeType(o.type), o.getStart(), o.getEnd()));
+            if (!o.modifiers) {
+                return;
+            }
+            parent.properties.push(new PropertyDeclaration_1.PropertyDeclaration(o.name.text, parse_utilities_1.getNodeVisibility(o), parse_utilities_1.getNodeType(o.type), !!o.questionToken, parse_utilities_1.containsModifier(o, typescript_1.SyntaxKind.StaticKeyword), o.getStart(), o.getEnd()));
+        }
+        else if (TypescriptGuards_1.isObjectBindingPattern(o.name) || TypescriptGuards_1.isArrayBindingPattern(o.name)) {
+            const identifiers = o.name;
+            const elements = [...identifiers.elements];
+            // TODO: BindingElement
+            ctor.parameters = ctor.parameters.concat(elements.map((bind) => {
+                if (TypescriptGuards_1.isIdentifier(bind.name)) {
+                    return new ParameterDeclaration_1.ParameterDeclaration(bind.name.text, undefined, bind.getStart(), bind.getEnd());
+                }
+            }).filter(Boolean));
+        }
+    });
+}
+exports.parseCtorParams = parseCtorParams;
+/**
+ * Parses a class node into its declaration. Calculates the properties, constructors and methods of the class.
+ *
+ * @export
+ * @param {Resource} tsResource
+ * @param {ClassDeclaration} node
+ */
+function parseClass(tsResource, node) {
+    const name = node.name ? node.name.text : parse_utilities_1.getDefaultResourceIdentifier(tsResource);
+    const classDeclaration = new ClassDeclaration_1.ClassDeclaration(name, parse_utilities_1.isNodeExported(node), node.getStart(), node.getEnd());
+    if (parse_utilities_1.isNodeDefaultExported(node)) {
+        classDeclaration.isExported = false;
+        tsResource.declarations.push(new DefaultDeclaration_1.DefaultDeclaration(classDeclaration.name, tsResource));
+    }
+    if (node.typeParameters) {
+        classDeclaration.typeParameters = node.typeParameters.map(param => param.getText());
+    }
+    if (node.members) {
+        node.members.forEach((o) => {
+            if (TypescriptGuards_1.isPropertyDeclaration(o)) {
+                const actualCount = classDeclaration.properties.length;
+                if (o.modifiers) {
+                    classDeclaration.properties.push(new PropertyDeclaration_1.PropertyDeclaration(o.name.text, parse_utilities_1.getNodeVisibility(o), parse_utilities_1.getNodeType(o.type), !!o.questionToken, parse_utilities_1.containsModifier(o, typescript_1.SyntaxKind.StaticKeyword), o.getStart(), o.getEnd()));
+                }
+                if (actualCount === classDeclaration.properties.length) {
+                    classDeclaration.properties.push(new PropertyDeclaration_1.PropertyDeclaration(o.name.text, parse_utilities_1.getNodeVisibility(o), parse_utilities_1.getNodeType(o.type), !!o.questionToken, parse_utilities_1.containsModifier(o, typescript_1.SyntaxKind.StaticKeyword), o.getStart(), o.getEnd()));
+                }
+                return;
+            }
+            if (TypescriptGuards_1.isGetAccessorDeclaration(o)) {
+                classDeclaration.accessors.push(new AccessorDeclaration_1.GetterDeclaration(o.name.text, parse_utilities_1.getNodeVisibility(o), parse_utilities_1.getNodeType(o.type), o.modifiers !== undefined && o.modifiers.some(m => m.kind === typescript_1.SyntaxKind.AbstractKeyword), parse_utilities_1.containsModifier(o, typescript_1.SyntaxKind.StaticKeyword), o.getStart(), o.getEnd()));
+            }
+            if (TypescriptGuards_1.isSetAccessorDeclaration(o)) {
+                classDeclaration.accessors.push(new AccessorDeclaration_1.SetterDeclaration(o.name.text, parse_utilities_1.getNodeVisibility(o), parse_utilities_1.getNodeType(o.type), o.modifiers !== undefined && o.modifiers.some(m => m.kind === typescript_1.SyntaxKind.AbstractKeyword), parse_utilities_1.containsModifier(o, typescript_1.SyntaxKind.StaticKeyword), o.getStart(), o.getEnd()));
+            }
+            if (TypescriptGuards_1.isConstructorDeclaration(o)) {
+                const ctor = new ConstructorDeclaration_1.ConstructorDeclaration(classDeclaration.name, o.getStart(), o.getEnd());
+                parseCtorParams(classDeclaration, ctor, o);
+                classDeclaration.ctor = ctor;
+                function_parser_1.parseFunctionParts(tsResource, ctor, o);
+            }
+            else if (TypescriptGuards_1.isMethodDeclaration(o)) {
+                const method = new MethodDeclaration_1.MethodDeclaration(o.name.text, o.modifiers !== undefined && o.modifiers.some(m => m.kind === typescript_1.SyntaxKind.AbstractKeyword), parse_utilities_1.getNodeVisibility(o), parse_utilities_1.getNodeType(o.type), !!o.questionToken, parse_utilities_1.containsModifier(o, typescript_1.SyntaxKind.StaticKeyword), parse_utilities_1.containsModifier(o, typescript_1.SyntaxKind.AsyncKeyword), o.getStart(), o.getEnd());
+                method.parameters = function_parser_1.parseMethodParams(o);
+                classDeclaration.methods.push(method);
+                function_parser_1.parseFunctionParts(tsResource, method, o);
+            }
+        });
+    }
+    if (node.heritageClauses) {
+        for (const heritageClause of node.heritageClauses) {
+            if (heritageClause.token == typescript_1.SyntaxKind.ExtendsKeyword) {
+                for (let heritageType of heritageClause.getChildren()) {
+                    const expressionText = heritageType.getText().trim();
+                    if (expressionText == 'extends')
+                        continue;
+                    classDeclaration.extends.push(parseType_1.parseTypeAndParameters(expressionText));
+                }
+            }
+            else if (heritageClause.token == typescript_1.SyntaxKind.ImplementsKeyword) {
+                for (let heritageType of heritageClause.getChildren()) {
+                    const expressionText = heritageType.getText().trim();
+                    if (expressionText == 'implements')
+                        continue;
+                    classDeclaration.implements.push(parseType_1.parseTypeAndParameters(expressionText));
+                }
+            }
+        }
+    }
+    parseClassIdentifiers(tsResource, node);
+    tsResource.declarations.push(classDeclaration);
+}
+exports.parseClass = parseClass;

package/dist/modules/typescript-parser/node-parser/enum-parser.d.ts

@@ -0,0 +1,10 @@
+import { EnumDeclaration } from 'typescript';
+import { Resource } from '../resources/Resource';
+/**
+ * Parses an enum node into the declaration.
+ *
+ * @export
+ * @param {resource} resource
+ * @param {EnumDeclaration} node
+ */
+export declare function parseEnum(resource: Resource, node: EnumDeclaration): void;

package/dist/modules/typescript-parser/node-parser/enum-parser.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEnum = void 0;
+const EnumDeclaration_1 = require("../declarations/EnumDeclaration");
+const parse_utilities_1 = require("./parse-utilities");
+/**
+ * Parses an enum node into the declaration.
+ *
+ * @export
+ * @param {resource} resource
+ * @param {EnumDeclaration} node
+ */
+function parseEnum(resource, node) {
+    const declaration = new EnumDeclaration_1.EnumDeclaration(node.name.text, parse_utilities_1.isNodeExported(node), node.getStart(), node.getEnd());
+    declaration.members = node.members.map(o => o.name.getText());
+    resource.declarations.push(declaration);
+}
+exports.parseEnum = parseEnum;

package/dist/modules/typescript-parser/node-parser/export-parser.d.ts

@@ -0,0 +1,10 @@
+import { ExportAssignment, ExportDeclaration } from 'typescript';
+import { Resource } from '../resources/Resource';
+/**
+ * Parses an export node into the declaration.
+ *
+ * @export
+ * @param {Resource} resource
+ * @param {(ExportDeclaration | ExportAssignment)} node
+ */
+export declare function parseExport(resource: Resource, node: ExportDeclaration | ExportAssignment): void;

package/dist/modules/typescript-parser/node-parser/export-parser.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseExport = void 0;
+const DefaultDeclaration_1 = require("../declarations/DefaultDeclaration");
+const AllExport_1 = require("../exports/AllExport");
+const AssignedExport_1 = require("../exports/AssignedExport");
+const NamedExport_1 = require("../exports/NamedExport");
+const SymbolSpecifier_1 = require("../SymbolSpecifier");
+const TypescriptGuards_1 = require("../type-guards/TypescriptGuards");
+const parse_utilities_1 = require("./parse-utilities");
+/**
+ * Parses an export node into the declaration.
+ *
+ * @export
+ * @param {Resource} resource
+ * @param {(ExportDeclaration | ExportAssignment)} node
+ */
+function parseExport(resource, node) {
+    if (TypescriptGuards_1.isExportDeclaration(node)) {
+        const tsExport = node;
+        if (!TypescriptGuards_1.isStringLiteral(tsExport.moduleSpecifier) && !tsExport.exportClause) {
+            return;
+        }
+        if (tsExport.getText().indexOf('*') > -1) {
+            resource.exports.push(new AllExport_1.AllExport(node.getStart(), node.getEnd(), tsExport.moduleSpecifier.text));
+        }
+        else if (tsExport.exportClause && TypescriptGuards_1.isNamedExports(tsExport.exportClause)) {
+            const lib = tsExport.moduleSpecifier;
+            const ex = new NamedExport_1.NamedExport(node.getStart(), node.getEnd(), lib ? lib.text : parse_utilities_1.getDefaultResourceIdentifier(resource));
+            ex.specifiers = tsExport.exportClause.elements.map(o => o.propertyName && o.name ?
+                new SymbolSpecifier_1.SymbolSpecifier(o.propertyName.text, o.name.text) :
+                new SymbolSpecifier_1.SymbolSpecifier(o.name.text));
+            for (const spec of ex.specifiers) {
+                if (resource.usages.indexOf(spec.alias || spec.specifier) === -1) {
+                    resource.usages.push(spec.alias || spec.specifier);
+                }
+            }
+            resource.exports.push(ex);
+        }
+    }
+    else {
+        const literal = node.expression;
+        if (node.isExportEquals) {
+            resource.exports.push(new AssignedExport_1.AssignedExport(node.getStart(), node.getEnd(), literal.text, resource));
+            if (resource.usages.indexOf(literal.text) === -1) {
+                resource.usages.push(literal.text);
+            }
+        }
+        else {
+            const name = (literal && literal.text) ? literal.text : parse_utilities_1.getDefaultResourceIdentifier(resource);
+            if (resource.usages.indexOf(name) === -1) {
+                resource.usages.push(name);
+            }
+            resource.declarations.push(new DefaultDeclaration_1.DefaultDeclaration(name, resource));
+        }
+    }
+}
+exports.parseExport = parseExport;

package/dist/modules/typescript-parser/node-parser/function-parser.d.ts

@@ -0,0 +1,33 @@
+import { FunctionDeclaration, MethodDeclaration, MethodSignature, Node } from 'typescript';
+import { ConstructorDeclaration as TshConstructor } from '../declarations/ConstructorDeclaration';
+import { FunctionDeclaration as TshFunction } from '../declarations/FunctionDeclaration';
+import { MethodDeclaration as TshMethod } from '../declarations/MethodDeclaration';
+import { ParameterDeclaration as TshParameter } from '../declarations/ParameterDeclaration';
+import { Resource } from '../resources/Resource';
+/**
+ * Parse the parts of a function. All functions / methods contain various information about used variables
+ * and parameters.
+ *
+ * @export
+ * @param {Resource} resource
+ * @param {(TshConstructor | TshMethod | TshFunction)} parent
+ * @param {Node} node
+ */
+export declare function parseFunctionParts(resource: Resource, parent: TshConstructor | TshMethod | TshFunction, node: Node): void;
+/**
+ * Parse method parameters.
+ *
+ * @export
+ * @param {(FunctionDeclaration | MethodDeclaration | MethodSignature)} node
+ * @returns {TshParameter[]}
+ */
+export declare function parseMethodParams(node: FunctionDeclaration | MethodDeclaration | MethodSignature): TshParameter[];
+/**
+ * Parses a function into its declaration.
+ * Parses the functions sub information like parameters and variables.
+ *
+ * @export
+ * @param {Resource} resource
+ * @param {FunctionDeclaration} node
+ */
+export declare function parseFunction(resource: Resource, node: FunctionDeclaration): void;

package/dist/modules/typescript-parser/node-parser/function-parser.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFunction = exports.parseMethodParams = exports.parseFunctionParts = void 0;
+const typescript_1 = require("typescript");
+const DefaultDeclaration_1 = require("../declarations/DefaultDeclaration");
+const FunctionDeclaration_1 = require("../declarations/FunctionDeclaration");
+const ParameterDeclaration_1 = require("../declarations/ParameterDeclaration");
+const TypescriptGuards_1 = require("../type-guards/TypescriptGuards");
+const identifier_parser_1 = require("./identifier-parser");
+const parse_utilities_1 = require("./parse-utilities");
+const variable_parser_1 = require("./variable-parser");
+/**
+ * Parse the parts of a function. All functions / methods contain various information about used variables
+ * and parameters.
+ *
+ * @export
+ * @param {Resource} resource
+ * @param {(TshConstructor | TshMethod | TshFunction)} parent
+ * @param {Node} node
+ */
+function parseFunctionParts(resource, parent, node) {
+    for (const child of node.getChildren()) {
+        switch (child.kind) {
+            case typescript_1.SyntaxKind.Identifier:
+                identifier_parser_1.parseIdentifier(resource, child);
+                break;
+            case typescript_1.SyntaxKind.VariableStatement:
+                variable_parser_1.parseVariable(parent, child);
+                break;
+            default:
+                break;
+        }
+        parseFunctionParts(resource, parent, child);
+    }
+}
+exports.parseFunctionParts = parseFunctionParts;
+/**
+ * Parse method parameters.
+ *
+ * @export
+ * @param {(FunctionDeclaration | MethodDeclaration | MethodSignature)} node
+ * @returns {TshParameter[]}
+ */
+function parseMethodParams(node) {
+    return node.parameters.reduce((all, cur) => {
+        const params = all;
+        if (TypescriptGuards_1.isIdentifier(cur.name)) {
+            params.push(new ParameterDeclaration_1.ParameterDeclaration(cur.name.text, parse_utilities_1.getNodeType(cur.type), cur.getStart(), cur.getEnd()));
+        }
+        else if (TypescriptGuards_1.isObjectBindingPattern(cur.name)) {
+            const elements = cur.name.elements;
+            let types = [];
+            const boundParam = new ParameterDeclaration_1.ObjectBoundParameterDeclaration(cur.getStart(), cur.getEnd());
+            if (cur.type && typescript_1.isTypeReferenceNode(cur.type)) {
+                boundParam.typeReference = parse_utilities_1.getNodeType(cur.type);
+            }
+            else if (cur.type && typescript_1.isTypeLiteralNode(cur.type)) {
+                types = cur.type.members
+                    .filter(member => TypescriptGuards_1.isPropertySignature(member))
+                    .map((signature) => parse_utilities_1.getNodeType(signature.type));
+            }
+            boundParam.parameters = elements.map((bindingElement, index) => new ParameterDeclaration_1.ParameterDeclaration(bindingElement.name.getText(), types[index], bindingElement.getStart(), bindingElement.getEnd()));
+            params.push(boundParam);
+        }
+        else if (TypescriptGuards_1.isArrayBindingPattern(cur.name)) {
+            const elements = cur.name.elements;
+            let types = [];
+            const boundParam = new ParameterDeclaration_1.ArrayBoundParameterDeclaration(cur.getStart(), cur.getEnd());
+            if (cur.type && typescript_1.isTypeReferenceNode(cur.type)) {
+                boundParam.typeReference = parse_utilities_1.getNodeType(cur.type);
+            }
+            else if (cur.type && typescript_1.isTupleTypeNode(cur.type)) {
+                types = cur.type.elementTypes.map(type => parse_utilities_1.getNodeType(type));
+            }
+            boundParam.parameters = elements.map((bindingElement, index) => new ParameterDeclaration_1.ParameterDeclaration(bindingElement.getText(), types[index], bindingElement.getStart(), bindingElement.getEnd()));
+            params.push(boundParam);
+        }
+        return params;
+    }, []);
+}
+exports.parseMethodParams = parseMethodParams;
+/**
+ * Parses a function into its declaration.
+ * Parses the functions sub information like parameters and variables.
+ *
+ * @export
+ * @param {Resource} resource
+ * @param {FunctionDeclaration} node
+ */
+function parseFunction(resource, node) {
+    const name = node.name ? node.name.text : parse_utilities_1.getDefaultResourceIdentifier(resource);
+    const func = new FunctionDeclaration_1.FunctionDeclaration(name, parse_utilities_1.isNodeExported(node), parse_utilities_1.containsModifier(node, typescript_1.SyntaxKind.AsyncKeyword), parse_utilities_1.getNodeType(node.type), node.getStart(), node.getEnd());
+    if (parse_utilities_1.isNodeDefaultExported(node)) {
+        func.isExported = false;
+        resource.declarations.push(new DefaultDeclaration_1.DefaultDeclaration(func.name, resource));
+    }
+    func.parameters = parseMethodParams(node);
+    resource.declarations.push(func);
+    parseFunctionParts(resource, func, node);
+}
+exports.parseFunction = parseFunction;

package/dist/modules/typescript-parser/node-parser/identifier-parser.d.ts

@@ -0,0 +1,10 @@
+import { Identifier } from 'typescript';
+import { Resource } from '../resources/Resource';
+/**
+ * Parses an identifier into a usage of a resource if the predicates are true.
+ *
+ * @export
+ * @param {Resource} resource
+ * @param {Identifier} node
+ */
+export declare function parseIdentifier(resource: Resource, node: Identifier): void;

package/dist/modules/typescript-parser/node-parser/identifier-parser.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIdentifier = void 0;
+const typescript_1 = require("typescript");
+const usageNotAllowedParents = [
+    typescript_1.SyntaxKind.ImportEqualsDeclaration,
+    typescript_1.SyntaxKind.ImportSpecifier,
+    typescript_1.SyntaxKind.NamespaceImport,
+    typescript_1.SyntaxKind.ClassDeclaration,
+    typescript_1.SyntaxKind.ImportEqualsDeclaration,
+    typescript_1.SyntaxKind.ImportClause,
+    typescript_1.SyntaxKind.ImportDeclaration,
+    typescript_1.SyntaxKind.InterfaceDeclaration,
+    typescript_1.SyntaxKind.ExportDeclaration,
+    typescript_1.SyntaxKind.ExportSpecifier,
+    typescript_1.SyntaxKind.ImportSpecifier,
+    typescript_1.SyntaxKind.FunctionDeclaration,
+    typescript_1.SyntaxKind.EnumDeclaration,
+    typescript_1.SyntaxKind.TypeAliasDeclaration,
+    typescript_1.SyntaxKind.MethodDeclaration,
+];
+const usageAllowedIfLast = [
+    typescript_1.SyntaxKind.Parameter,
+    typescript_1.SyntaxKind.PropertyDeclaration,
+    typescript_1.SyntaxKind.VariableDeclaration,
+    typescript_1.SyntaxKind.BinaryExpression,
+];
+const usagePredicates = [
+    (o) => o.parent !== undefined && usageNotAllowedParents.indexOf(o.parent.kind) === -1,
+    allowedIfLastIdentifier,
+    allowedIfPropertyAccessFirst,
+];
+/**
+ * Predicate function to determine if the node is possible as a "usage".
+ * Checks for the node identifier to be the last of the identifier list.
+ *
+ * @param {Node} node
+ * @returns {boolean}
+ */
+function allowedIfLastIdentifier(node) {
+    if (!node.parent) {
+        return false;
+    }
+    if (usageAllowedIfLast.indexOf(node.parent.kind) === -1) {
+        return true;
+    }
+    const children = node.parent.getChildren().filter(o => o.kind === typescript_1.SyntaxKind.Identifier);
+    return children.length === 1 || children.indexOf(node) === 1;
+}
+/**
+ * Predicate function to determine if the node is possible as a "usage".
+ * Checks if the identifier is on the lefthand side of a property access.
+ *
+ * @param {Node} node
+ * @returns {boolean}
+ */
+function allowedIfPropertyAccessFirst(node) {
+    if (!node.parent) {
+        return false;
+    }
+    if (node.parent.kind !== typescript_1.SyntaxKind.PropertyAccessExpression) {
+        return true;
+    }
+    const children = node.parent.getChildren();
+    return children.indexOf(node) === 0;
+}
+/**
+ * Parses an identifier into a usage of a resource if the predicates are true.
+ *
+ * @export
+ * @param {Resource} resource
+ * @param {Identifier} node
+ */
+function parseIdentifier(resource, node) {
+    if (node.parent && usagePredicates.every(predicate => predicate(node))) {
+        if (resource.usages.indexOf(node.text) === -1) {
+            resource.usages.push(node.text);
+        }
+    }
+}
+exports.parseIdentifier = parseIdentifier;

package/dist/modules/typescript-parser/node-parser/import-parser.d.ts

@@ -0,0 +1,10 @@
+import { ImportDeclaration, ImportEqualsDeclaration } from 'typescript';
+import { Resource } from '../resources/Resource';
+/**
+ * Parses an import node into the declaration.
+ *
+ * @export
+ * @param {Resource} resource
+ * @param {(ImportDeclaration | ImportEqualsDeclaration)} node
+ */
+export declare function parseImport(resource: Resource, node: ImportDeclaration | ImportEqualsDeclaration): void;

package/dist/modules/typescript-parser/node-parser/import-parser.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseImport = void 0;
+const ExternalModuleImport_1 = require("../imports/ExternalModuleImport");
+const NamedImport_1 = require("../imports/NamedImport");
+const NamespaceImport_1 = require("../imports/NamespaceImport");
+const StringImport_1 = require("../imports/StringImport");
+const SymbolSpecifier_1 = require("../SymbolSpecifier");
+const TypescriptGuards_1 = require("../type-guards/TypescriptGuards");
+/**
+ * Parses an import node into the declaration.
+ *
+ * @export
+ * @param {Resource} resource
+ * @param {(ImportDeclaration | ImportEqualsDeclaration)} node
+ */
+function parseImport(resource, node) {
+    if (TypescriptGuards_1.isImportDeclaration(node)) {
+        if (node.importClause && TypescriptGuards_1.isNamespaceImport(node.importClause.namedBindings)) {
+            const lib = node.moduleSpecifier;
+            const alias = node.importClause.namedBindings.name;
+            resource.imports.push(new NamespaceImport_1.NamespaceImport(lib.text, alias.text, node.getStart(), node.getEnd()));
+        }
+        else if (node.importClause && (TypescriptGuards_1.isNamedImports(node.importClause.namedBindings) || node.importClause.name)) {
+            const lib = node.moduleSpecifier;
+            const tsImport = new NamedImport_1.NamedImport(lib.text, node.getStart(), node.getEnd());
+            if (node.importClause.name) {
+                tsImport.defaultAlias = node.importClause.name.text;
+            }
+            if (node.importClause.namedBindings) {
+                const bindings = node.importClause.namedBindings;
+                tsImport.specifiers = bindings.elements.map(o => o.propertyName && o.name ?
+                    new SymbolSpecifier_1.SymbolSpecifier(o.propertyName.text, o.name.text) :
+                    new SymbolSpecifier_1.SymbolSpecifier(o.name.text));
+                const defaultImport = tsImport.specifiers.find(imp => imp.specifier === 'default' && !!imp.alias);
+                if (defaultImport) {
+                    tsImport.specifiers.splice(tsImport.specifiers.indexOf(defaultImport), 1);
+                    tsImport.defaultAlias = defaultImport.alias;
+                }
+            }
+            resource.imports.push(tsImport);
+        }
+        else if (node.moduleSpecifier && TypescriptGuards_1.isStringLiteral(node.moduleSpecifier)) {
+            const lib = node.moduleSpecifier;
+            resource.imports.push(new StringImport_1.StringImport(lib.text, node.getStart(), node.getEnd()));
+        }
+    }
+    else if (TypescriptGuards_1.isExternalModuleReference(node.moduleReference)) {
+        const alias = node.name;
+        const lib = node.moduleReference.expression;
+        resource.imports.push(new ExternalModuleImport_1.ExternalModuleImport(lib.text, alias.text, node.getStart(), node.getEnd()));
+    }
+}
+exports.parseImport = parseImport;