@proteinjs/reflection-build 1.0.3 → 1.0.5

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

@@ -0,0 +1,11 @@
+"use strict";
+// export * from './class-parser';
+// export * from './enum-parser';
+// export * from './export-parser';
+// export * from './function-parser';
+// export * from './identifier-parser';
+// export * from './import-parser';
+// export * from './interface-parser';
+// export * from './module-parser';
+// export * from './type-alias-parser';
+// export * from './variable-parser';

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

@@ -0,0 +1,11 @@
+import { InterfaceDeclaration } from 'typescript';
+import { Resource } from '../resources/Resource';
+/**
+ * Parses an interface node into its declaration.
+ * Calculates the property and method defintions of the interface as well.
+ *
+ * @export
+ * @param {Resource} resource
+ * @param {InterfaceDeclaration} node
+ */
+export declare function parseInterface(resource: Resource, node: InterfaceDeclaration): void;

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInterface = void 0;
+const typescript_1 = require("typescript");
+const DefaultDeclaration_1 = require("../declarations/DefaultDeclaration");
+const InterfaceDeclaration_1 = require("../declarations/InterfaceDeclaration");
+const MethodDeclaration_1 = require("../declarations/MethodDeclaration");
+const PropertyDeclaration_1 = require("../declarations/PropertyDeclaration");
+const TypescriptGuards_1 = require("../type-guards/TypescriptGuards");
+const function_parser_1 = require("./function-parser");
+const parse_utilities_1 = require("./parse-utilities");
+const parseType_1 = require("./changes/parseType");
+/**
+ * Parses an interface node into its declaration.
+ * Calculates the property and method defintions of the interface as well.
+ *
+ * @export
+ * @param {Resource} resource
+ * @param {InterfaceDeclaration} node
+ */
+function parseInterface(resource, node) {
+    const name = node.name ? node.name.text : parse_utilities_1.getDefaultResourceIdentifier(resource);
+    const interfaceDeclaration = new InterfaceDeclaration_1.InterfaceDeclaration(name, parse_utilities_1.isNodeExported(node), node.getStart(), node.getEnd());
+    if (parse_utilities_1.isNodeDefaultExported(node)) {
+        interfaceDeclaration.isExported = false;
+        resource.declarations.push(new DefaultDeclaration_1.DefaultDeclaration(interfaceDeclaration.name, resource));
+    }
+    if (node.members) {
+        node.members.forEach((o) => {
+            if (TypescriptGuards_1.isPropertySignature(o)) {
+                interfaceDeclaration.properties.push(new PropertyDeclaration_1.PropertyDeclaration(o.name.text, 2 /* Public */, 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.isMethodSignature(o)) {
+                const method = new MethodDeclaration_1.MethodDeclaration(o.name.text, true, 2 /* Public */, 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);
+                interfaceDeclaration.methods.push(method);
+            }
+        });
+    }
+    if (node.typeParameters) {
+        interfaceDeclaration.typeParameters = node.typeParameters.map(param => param.getText());
+    }
+    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;
+                    interfaceDeclaration.extends.push(parseType_1.parseTypeAndParameters(expressionText));
+                }
+            }
+        }
+    }
+    resource.declarations.push(interfaceDeclaration);
+}
+exports.parseInterface = parseInterface;

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

@@ -0,0 +1,12 @@
+import { ModuleDeclaration } from 'typescript';
+import { Resource } from '../resources/Resource';
+/**
+ * Parse a module to its declaration. Create a new namespace or module declaration and return it to
+ * be used as the new "container".
+ *
+ * @export
+ * @param {Resource} resource
+ * @param {ModuleDeclaration} node
+ * @returns {Resource}
+ */
+export declare function parseModule(resource: Resource, node: ModuleDeclaration): Resource;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseModule = void 0;
+const typescript_1 = require("typescript");
+const Module_1 = require("../resources/Module");
+const Namespace_1 = require("../resources/Namespace");
+/**
+ * Parse a module to its declaration. Create a new namespace or module declaration and return it to
+ * be used as the new "container".
+ *
+ * @export
+ * @param {Resource} resource
+ * @param {ModuleDeclaration} node
+ * @returns {Resource}
+ */
+function parseModule(resource, node) {
+    const newResource = (node.flags & typescript_1.NodeFlags.Namespace) === typescript_1.NodeFlags.Namespace ?
+        new Namespace_1.Namespace(node.name.text, node.getStart(), node.getEnd()) :
+        new Module_1.Module(node.name.text, node.getStart(), node.getEnd());
+    resource.resources.push(newResource);
+    return newResource;
+}
+exports.parseModule = parseModule;

package/dist/modules/typescript-parser/node-parser/parse-utilities.d.ts

@@ -0,0 +1,55 @@
+import { Node, SyntaxKind, TypeNode } from 'typescript';
+import { DeclarationVisibility } from '../declarations/DeclarationVisibility';
+import { Resource } from '../resources/Resource';
+/**
+ * Checks if the given typescript node has the exported flag.
+ * (e.g. export class Foobar).
+ *
+ * @export
+ * @param {Node} node
+ * @returns {boolean}
+ */
+export declare function isNodeExported(node: Node): boolean;
+/**
+ * Checks if the given typescript node has the default flag.
+ * (e.g. export default class Foobar).
+ *
+ * @export
+ * @param {Node} node
+ * @returns {boolean}
+ */
+export declare function isNodeDefaultExported(node: Node): boolean;
+/**
+ * Returns the type text (type information) for a given node.
+ *
+ * @export
+ * @param {(TypeNode | undefined)} node
+ * @returns {(string | undefined)}
+ */
+export declare function getNodeType(node: TypeNode | undefined): string | undefined;
+/**
+ * Checks if a node contains a certain modifier (of a given kind)
+ *
+ * @export
+ * @param {Node} node
+ * @param {SyntaxKind} modifierKind
+ * @returns {boolean}
+ */
+export declare function containsModifier(node: Node, modifierKind: SyntaxKind): boolean;
+/**
+ * Returns the enum value (visibility) of a node.
+ *
+ * @export
+ * @param {Node} node
+ * @returns {(DeclarationVisibility | undefined)}
+ */
+export declare function getNodeVisibility(node: Node): DeclarationVisibility | undefined;
+/**
+ * Function that calculates the default name of a resource.
+ * This is used when a default export has no name (i.e. export class {}).
+ *
+ * @export
+ * @param {TsResource} resource
+ * @returns {string}
+ */
+export declare function getDefaultResourceIdentifier(resource: Resource): string;

package/dist/modules/typescript-parser/node-parser/parse-utilities.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultResourceIdentifier = exports.getNodeVisibility = exports.containsModifier = exports.getNodeType = exports.isNodeDefaultExported = exports.isNodeExported = void 0;
+const typescript_1 = require("typescript");
+const File_1 = require("../resources/File");
+/**
+ * Checks if the given typescript node has the exported flag.
+ * (e.g. export class Foobar).
+ *
+ * @export
+ * @param {Node} node
+ * @returns {boolean}
+ */
+function isNodeExported(node) {
+    const flags = typescript_1.getCombinedModifierFlags(node);
+    return (flags & typescript_1.ModifierFlags.Export) === typescript_1.ModifierFlags.Export;
+}
+exports.isNodeExported = isNodeExported;
+/**
+ * Checks if the given typescript node has the default flag.
+ * (e.g. export default class Foobar).
+ *
+ * @export
+ * @param {Node} node
+ * @returns {boolean}
+ */
+function isNodeDefaultExported(node) {
+    const flags = typescript_1.getCombinedModifierFlags(node);
+    return (flags & typescript_1.ModifierFlags.Default) === typescript_1.ModifierFlags.Default;
+}
+exports.isNodeDefaultExported = isNodeDefaultExported;
+/**
+ * Returns the type text (type information) for a given node.
+ *
+ * @export
+ * @param {(TypeNode | undefined)} node
+ * @returns {(string | undefined)}
+ */
+function getNodeType(node) {
+    return node ? node.getText() : undefined;
+}
+exports.getNodeType = getNodeType;
+/**
+ * Checks if a node contains a certain modifier (of a given kind)
+ *
+ * @export
+ * @param {Node} node
+ * @param {SyntaxKind} modifierKind
+ * @returns {boolean}
+ */
+function containsModifier(node, modifierKind) {
+    if (!node.modifiers)
+        return false;
+    return node.modifiers.some(mod => mod.kind === modifierKind);
+}
+exports.containsModifier = containsModifier;
+/**
+ * Returns the enum value (visibility) of a node.
+ *
+ * @export
+ * @param {Node} node
+ * @returns {(DeclarationVisibility | undefined)}
+ */
+function getNodeVisibility(node) {
+    if (!node.modifiers) {
+        return undefined;
+    }
+    for (const modifier of node.modifiers) {
+        switch (modifier.kind) {
+            case typescript_1.SyntaxKind.PublicKeyword:
+                return 2 /* Public */;
+            case typescript_1.SyntaxKind.ProtectedKeyword:
+                return 1 /* Protected */;
+            case typescript_1.SyntaxKind.PrivateKeyword:
+                return 0 /* Private */;
+            default:
+                break;
+        }
+    }
+}
+exports.getNodeVisibility = getNodeVisibility;
+/**
+ * Function that calculates the default name of a resource.
+ * This is used when a default export has no name (i.e. export class {}).
+ *
+ * @export
+ * @param {TsResource} resource
+ * @returns {string}
+ */
+function getDefaultResourceIdentifier(resource) {
+    if (resource instanceof File_1.File && resource.isWorkspaceFile) {
+        return resource.parsedPath.name;
+    }
+    return resource.identifier;
+}
+exports.getDefaultResourceIdentifier = getDefaultResourceIdentifier;

package/dist/modules/typescript-parser/node-parser/traverse-ast.d.ts

@@ -0,0 +1 @@
+export declare function traverseAst(root: Node, visit: (node: Node) => void, skipContents?: (node: Node) => boolean): void;

package/dist/modules/typescript-parser/node-parser/traverse-ast.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseAst = void 0;
+function traverseAst(root, visit, skipContents) {
+    const stack = root.getChildren();
+    for (let node = stack.shift(); node !== undefined; node = stack.shift()) {
+        visit(node);
+        if (skipContents && skipContents(node)) {
+            continue;
+        }
+        stack.unshift(...node.getChildren());
+    }
+}
+exports.traverseAst = traverseAst;

package/dist/modules/typescript-parser/node-parser/type-alias-parser.d.ts

@@ -0,0 +1,10 @@
+import { TypeAliasDeclaration } from 'typescript';
+import { Resource } from '../resources/Resource';
+/**
+ * Parses a type alias into the declaration.
+ *
+ * @export
+ * @param {Resource} resource
+ * @param {TypeAliasDeclaration} node
+ */
+export declare function parseTypeAlias(resource: Resource, node: TypeAliasDeclaration): void;

package/dist/modules/typescript-parser/node-parser/type-alias-parser.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTypeAlias = void 0;
+const TypeAliasDeclaration_1 = require("../declarations/TypeAliasDeclaration");
+const parse_utilities_1 = require("./parse-utilities");
+const parseType_1 = require("./changes/parseType");
+/**
+ * Parses a type alias into the declaration.
+ *
+ * @export
+ * @param {Resource} resource
+ * @param {TypeAliasDeclaration} node
+ */
+function parseTypeAlias(resource, node) {
+    let typeParameters = [];
+    if (node.typeParameters)
+        typeParameters = node.typeParameters.map(param => param.getText());
+    resource.declarations.push(new TypeAliasDeclaration_1.TypeAliasDeclaration(node.name.text, parse_utilities_1.isNodeExported(node), typeParameters, parseType_1.parseType(node), node.getStart(), node.getEnd()));
+}
+exports.parseTypeAlias = parseTypeAlias;

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

@@ -0,0 +1,11 @@
+import { VariableStatement } from 'typescript';
+import { CallableDeclaration } from '../declarations/Declaration';
+import { Resource } from '../resources/Resource';
+/**
+ * Parse a variable. Information such as "is the variable const" are calculated here.
+ *
+ * @export
+ * @param {(Resource | CallableDeclaration)} parent
+ * @param {VariableStatement} node
+ */
+export declare function parseVariable(parent: Resource | CallableDeclaration, node: VariableStatement): void;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVariable = void 0;
+const typescript_1 = require("typescript");
+const VariableDeclaration_1 = require("../declarations/VariableDeclaration");
+const TypescriptHeroGuards_1 = require("../type-guards/TypescriptHeroGuards");
+const parse_utilities_1 = require("./parse-utilities");
+const parseType_1 = require("./changes/parseType");
+/**
+ * Parse a variable. Information such as "is the variable const" are calculated here.
+ *
+ * @export
+ * @param {(Resource | CallableDeclaration)} parent
+ * @param {VariableStatement} node
+ */
+function parseVariable(parent, node) {
+    const isConst = node.declarationList.getChildren().some(o => o.kind === typescript_1.SyntaxKind.ConstKeyword);
+    if (node.declarationList && node.declarationList.declarations) {
+        node.declarationList.declarations.forEach((o) => {
+            const declaration = new VariableDeclaration_1.VariableDeclaration(o.name.getText(), isConst, parse_utilities_1.isNodeExported(node), parseType_1.parseType(o), node.getStart(), node.getEnd());
+            if (TypescriptHeroGuards_1.isCallableDeclaration(parent)) {
+                parent.variables.push(declaration);
+            }
+            else {
+                parent.declarations.push(declaration);
+            }
+        });
+    }
+}
+exports.parseVariable = parseVariable;