@proteinjs/reflection-build 1.0.3 → 1.0.5

package/dist/modules/typescript-parser/declarations/Declaration.d.ts

@@ -0,0 +1,215 @@
+import { Node } from '../Node';
+import { AccessorDeclaration } from './AccessorDeclaration';
+import { DeclarationVisibility } from './DeclarationVisibility';
+import { MethodDeclaration } from './MethodDeclaration';
+import { ParameterDeclaration } from './ParameterDeclaration';
+import { PropertyDeclaration } from './PropertyDeclaration';
+import { VariableDeclaration } from './VariableDeclaration';
+import { Type } from '../node-parser/changes/parseType';
+/**
+ * Basic interface for all declarations. Defines the basic needed information for a typescript declaration.
+ *
+ * @export
+ * @interface Declaration
+ * @extends {Node}
+ */
+export interface Declaration extends Node {
+    /**
+     * The name of the declaration.
+     *
+     * @type {string}
+     * @memberof Declaration
+     */
+    name: string;
+}
+/**
+ * Interface for all typed declarations. Those declarations contain a type that must be taken care of.
+ * (e.g. 'string' or 'number')
+ *
+ * @export
+ * @interface TypedDeclaration
+ * @extends {Declaration}
+ */
+export interface TypedDeclaration extends Declaration {
+    /**
+     * The type of the declaration.
+     *
+     * @type {(string | undefined)}
+     * @example "string"
+     * @example "Declaration[]"
+     * @memberof TypedDeclaration
+     */
+    type: Type | string | undefined;
+}
+/**
+ * Interface for generic type declarations. Those declarations are able to be used in a generic way.
+ * Examples are: classes, interfaces, methods and such.
+ *
+ * @export
+ * @interface GenericDeclaration
+ * @extends {Declaration}
+ */
+export interface GenericDeclaration extends Declaration {
+    /**
+     * List of type parameters
+     *
+     * @type {(string[] | undefined)}
+     * @memberof GenericDeclaration
+     *
+     * @example
+     * ['T', 'TResult', 'TError']
+     */
+    typeParameters: string[] | undefined;
+}
+/**
+ * Interface for exportable declarations. Does contain information about the export status of a declaration.
+ *
+ * @export
+ * @interface ExportableDeclaration
+ * @extends {Declaration}
+ */
+export interface ExportableDeclaration extends Declaration {
+    /**
+     * Indicates if the declaration is exported (i.e. export function ...) or not.
+     *
+     * @type {boolean}
+     * @memberof ExportableDeclaration
+     */
+    isExported: boolean;
+}
+/**
+ * Interface for visible declarations. Does contain information about the visibility of the declaration.
+ *
+ * @export
+ * @interface ScopedDeclaration
+ * @extends {Declaration}
+ */
+export interface ScopedDeclaration extends Declaration {
+    /**
+     * Defines the visibility scope of the declaration. Can be undefined, in which case there
+     * is no visibility given (e.g. methods in interfaces).
+     *
+     * @type {(DeclarationVisibility | undefined)}
+     * @memberof ScopedDeclaration
+     */
+    visibility: DeclarationVisibility | undefined;
+}
+/**
+ * Interface for class like constructs. Contain properties and methods that are contained.
+ * Examples are classes, interfaces, abstract classes, etc.
+ *
+ * @export
+ * @interface ClassLikeDeclaration
+ * @extends {Declaration}
+ */
+export interface ClassLikeDeclaration extends Declaration {
+    /**
+     * Accessors of this class.
+     *
+     * @type {AccessorDeclaration[]}
+     * @memberof ClassLikeDeclaration
+     */
+    accessors: AccessorDeclaration[];
+    /**
+     * The properties of the declaration.
+     *
+     * @type {PropertyDeclaration[]}
+     * @memberof ClassLikeDeclaration
+     */
+    properties: PropertyDeclaration[];
+    /**
+     * The methods of the declaration.
+     *
+     * @type {MethodDeclaration[]}
+     * @memberof ClassLikeDeclaration
+     */
+    methods: MethodDeclaration[];
+}
+/**
+ * Interface for callable declarations. Contains lists for parameters and used variables in the callable
+ * definitions.
+ *
+ * @export
+ * @interface CallableDeclaration
+ * @extends {Declaration}
+ */
+export interface CallableDeclaration extends Declaration {
+    /**
+     * List of used parameters in the callable node.
+     *
+     * @type {ParameterDeclaration[]}
+     * @memberof CallableDeclaration
+     */
+    parameters: ParameterDeclaration[];
+    /**
+     * List of used variables in the callable node.
+     *
+     * @type {VariableDeclaration[]}
+     * @memberof CallableDeclaration
+     */
+    variables: VariableDeclaration[];
+}
+/**
+ * Interface for possible abstract declarations. Contains information if the element is abstract or not.
+ *
+ * @export
+ * @interface AbstractDeclaration
+ * @extends {Declaration}
+ */
+export interface AbstractDeclaration extends Declaration {
+    /**
+     * Defines if the declaration is abstract or not.
+     *
+     * @type {boolean}
+     * @memberof AbstractDeclaration
+     */
+    isAbstract: boolean;
+}
+/**
+ * Interface for possible optional declarations. Contains information if the element is optional or not.
+ *
+ * @export
+ * @interface OptionalDeclaration
+ * @extends {Declaration}
+ */
+export interface OptionalDeclaration extends Declaration {
+    /**
+     * Defines if the declaration is optional or not.
+     *
+     * @type {boolean}
+     * @memberof OptionalDeclaration
+     */
+    isOptional: boolean;
+}
+/**
+ * Interface for possible static declarations.
+ *
+ * @export
+ * @interface StaticDeclaration
+ * @extends {Declaration}
+ */
+export interface StaticDeclaration extends Declaration {
+    /**
+     * Defines if the declaration is static or not.
+     *
+     * @type {boolean}
+     * @memberof StaticDeclaration
+     */
+    isStatic: boolean;
+}
+/**
+ * Interface for possible async declarations.
+ *
+ * @export
+ * @interface AsyncDeclaration
+ * @extends {Declaration}
+ */
+export interface AsyncDeclaration extends Declaration {
+    /**
+     * Defines if the declaration is async or not.
+     *
+     * @type {boolean}
+     * @memberof AsyncDeclaration
+     */
+    isAsync: boolean;
+}

package/dist/modules/typescript-parser/declarations/Declaration.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/modules/typescript-parser/declarations/DeclarationInfo.d.ts

@@ -0,0 +1,13 @@
+import { Declaration } from './Declaration';
+/**
+ * Class that defines information about a declaration.
+ * Contains the declaration and the origin of the declaration.
+ *
+ * @export
+ * @class DeclarationInfo
+ */
+export declare class DeclarationInfo {
+    declaration: Declaration;
+    from: string;
+    constructor(declaration: Declaration, from: string);
+}

package/dist/modules/typescript-parser/declarations/DeclarationInfo.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeclarationInfo = void 0;
+/**
+ * Class that defines information about a declaration.
+ * Contains the declaration and the origin of the declaration.
+ *
+ * @export
+ * @class DeclarationInfo
+ */
+class DeclarationInfo {
+    constructor(declaration, from) {
+        this.declaration = declaration;
+        this.from = from;
+    }
+}
+exports.DeclarationInfo = DeclarationInfo;

package/dist/modules/typescript-parser/declarations/DeclarationVisibility.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Returns the visibility string for a given enum value.
+ *
+ * @param {DeclarationVisibility} [visibility]
+ * @returns {string}
+ */
+export declare function getVisibilityText(visibility?: DeclarationVisibility): string;
+/**
+ * Visibility of a class or interface property, as well as a method.
+ *
+ * @export
+ * @enum {number}
+ */
+export declare const enum DeclarationVisibility {
+    Private = 0,
+    Protected = 1,
+    Public = 2
+}

package/dist/modules/typescript-parser/declarations/DeclarationVisibility.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVisibilityText = void 0;
+/**
+ * Returns the visibility string for a given enum value.
+ *
+ * @param {DeclarationVisibility} [visibility]
+ * @returns {string}
+ */
+function getVisibilityText(visibility) {
+    switch (visibility) {
+        case 0 /* Private */:
+            return 'private';
+        case 2 /* Public */:
+            return 'public';
+        case 1 /* Protected */:
+            return 'protected';
+        default:
+            return '';
+    }
+}
+exports.getVisibilityText = getVisibilityText;

package/dist/modules/typescript-parser/declarations/DefaultDeclaration.d.ts

@@ -0,0 +1,21 @@
+import { Resource } from '../resources/Resource';
+import { Declaration, ExportableDeclaration } from './Declaration';
+/**
+ * Default declaration. Is used when a file exports something as its default.
+ * Primary use is to ask the user about a name for the default export.
+ * Is kind of an abstract declaration since there is no real declaration.
+ *
+ * @export
+ * @class DefaultDeclaration
+ * @implements {ExportableDeclaration}
+ */
+export declare class DefaultDeclaration implements ExportableDeclaration {
+    name: string;
+    private resource;
+    start?: number | undefined;
+    end?: number | undefined;
+    readonly isExported: boolean;
+    private exported;
+    get exportedDeclaration(): Declaration;
+    constructor(name: string, resource: Resource, start?: number | undefined, end?: number | undefined);
+}

package/dist/modules/typescript-parser/declarations/DefaultDeclaration.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultDeclaration = void 0;
+/**
+ * Default declaration. Is used when a file exports something as its default.
+ * Primary use is to ask the user about a name for the default export.
+ * Is kind of an abstract declaration since there is no real declaration.
+ *
+ * @export
+ * @class DefaultDeclaration
+ * @implements {ExportableDeclaration}
+ */
+class DefaultDeclaration {
+    constructor(name, resource, start, end) {
+        this.name = name;
+        this.resource = resource;
+        this.start = start;
+        this.end = end;
+        this.isExported = true;
+    }
+    get exportedDeclaration() {
+        if (!this.exported) {
+            this.exported = this.resource.declarations.find(o => o.name === this.name);
+        }
+        return this.exported;
+    }
+}
+exports.DefaultDeclaration = DefaultDeclaration;

package/dist/modules/typescript-parser/declarations/EnumDeclaration.d.ts

@@ -0,0 +1,16 @@
+import { ExportableDeclaration } from './Declaration';
+/**
+ * Enum declaration.
+ *
+ * @export
+ * @class EnumDeclaration
+ * @implements {ExportableDeclaration}
+ */
+export declare class EnumDeclaration implements ExportableDeclaration {
+    name: string;
+    isExported: boolean;
+    start?: number | undefined;
+    end?: number | undefined;
+    members: string[];
+    constructor(name: string, isExported: boolean, start?: number | undefined, end?: number | undefined);
+}

package/dist/modules/typescript-parser/declarations/EnumDeclaration.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumDeclaration = void 0;
+/**
+ * Enum declaration.
+ *
+ * @export
+ * @class EnumDeclaration
+ * @implements {ExportableDeclaration}
+ */
+class EnumDeclaration {
+    constructor(name, isExported, start, end) {
+        this.name = name;
+        this.isExported = isExported;
+        this.start = start;
+        this.end = end;
+        this.members = [];
+    }
+}
+exports.EnumDeclaration = EnumDeclaration;

package/dist/modules/typescript-parser/declarations/FunctionDeclaration.d.ts

@@ -0,0 +1,23 @@
+import { AsyncDeclaration, CallableDeclaration, ExportableDeclaration } from './Declaration';
+import { ParameterDeclaration } from './ParameterDeclaration';
+import { VariableDeclaration } from './VariableDeclaration';
+/**
+ * Function declaration. Like the MethodDeclaration it contains the base info about the function
+ * and additional stuff.
+ *
+ * @export
+ * @class FunctionDeclaration
+ * @implements {CallableDeclaration}
+ * @implements {ExportableDeclaration}
+ */
+export declare class FunctionDeclaration implements AsyncDeclaration, CallableDeclaration, ExportableDeclaration {
+    name: string;
+    isExported: boolean;
+    isAsync: boolean;
+    type?: string | undefined;
+    start?: number | undefined;
+    end?: number | undefined;
+    parameters: ParameterDeclaration[];
+    variables: VariableDeclaration[];
+    constructor(name: string, isExported: boolean, isAsync: boolean, type?: string | undefined, start?: number | undefined, end?: number | undefined);
+}

package/dist/modules/typescript-parser/declarations/FunctionDeclaration.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionDeclaration = void 0;
+/**
+ * Function declaration. Like the MethodDeclaration it contains the base info about the function
+ * and additional stuff.
+ *
+ * @export
+ * @class FunctionDeclaration
+ * @implements {CallableDeclaration}
+ * @implements {ExportableDeclaration}
+ */
+class FunctionDeclaration {
+    constructor(name, isExported, isAsync, type, start, end) {
+        this.name = name;
+        this.isExported = isExported;
+        this.isAsync = isAsync;
+        this.type = type;
+        this.start = start;
+        this.end = end;
+        this.parameters = [];
+        this.variables = [];
+    }
+}
+exports.FunctionDeclaration = FunctionDeclaration;

package/dist/modules/typescript-parser/declarations/InterfaceDeclaration.d.ts

@@ -0,0 +1,27 @@
+import { AccessorDeclaration } from './AccessorDeclaration';
+import { ClassLikeDeclaration, ExportableDeclaration, GenericDeclaration } from './Declaration';
+import { MethodDeclaration } from './MethodDeclaration';
+import { PropertyDeclaration } from './PropertyDeclaration';
+/**
+ * Interface declaration that contains defined properties and methods.
+ *
+ * @export
+ * @class InterfaceDeclaration
+ * @implements {ExportableDeclaration}
+ * @implements {GenericDeclaration}
+ */
+export declare class InterfaceDeclaration implements ClassLikeDeclaration, ExportableDeclaration, GenericDeclaration {
+    name: string;
+    isExported: boolean;
+    start?: number | undefined;
+    end?: number | undefined;
+    accessors: AccessorDeclaration[];
+    typeParameters: string[] | undefined;
+    properties: PropertyDeclaration[];
+    methods: MethodDeclaration[];
+    extends: {
+        name: string;
+        typeParameters: string[];
+    }[];
+    constructor(name: string, isExported: boolean, start?: number | undefined, end?: number | undefined);
+}

package/dist/modules/typescript-parser/declarations/InterfaceDeclaration.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterfaceDeclaration = void 0;
+/**
+ * Interface declaration that contains defined properties and methods.
+ *
+ * @export
+ * @class InterfaceDeclaration
+ * @implements {ExportableDeclaration}
+ * @implements {GenericDeclaration}
+ */
+class InterfaceDeclaration {
+    constructor(name, isExported, start, end) {
+        this.name = name;
+        this.isExported = isExported;
+        this.start = start;
+        this.end = end;
+        this.accessors = [];
+        this.properties = [];
+        this.methods = [];
+        this.extends = [];
+    }
+}
+exports.InterfaceDeclaration = InterfaceDeclaration;

package/dist/modules/typescript-parser/declarations/MethodDeclaration.d.ts

@@ -0,0 +1,28 @@
+import { AbstractDeclaration, AsyncDeclaration, CallableDeclaration, OptionalDeclaration, ScopedDeclaration, StaticDeclaration, TypedDeclaration } from './Declaration';
+import { DeclarationVisibility } from './DeclarationVisibility';
+import { ParameterDeclaration } from './ParameterDeclaration';
+import { VariableDeclaration } from './VariableDeclaration';
+/**
+ * Method declaration. A method is contained in an interface or a class.
+ * Contains information abount the method itself.
+ *
+ * @export
+ * @class MethodDeclaration
+ * @implements {CallableDeclaration}
+ * @implements {ScopedDeclaration}
+ * @implements {TypedDeclaration}
+ */
+export declare class MethodDeclaration implements AbstractDeclaration, AsyncDeclaration, CallableDeclaration, OptionalDeclaration, ScopedDeclaration, StaticDeclaration, TypedDeclaration {
+    name: string;
+    isAbstract: boolean;
+    visibility: DeclarationVisibility | undefined;
+    type: string | undefined;
+    isOptional: boolean;
+    isStatic: boolean;
+    isAsync: boolean;
+    start?: number | undefined;
+    end?: number | undefined;
+    parameters: ParameterDeclaration[];
+    variables: VariableDeclaration[];
+    constructor(name: string, isAbstract: boolean, visibility: DeclarationVisibility | undefined, type: string | undefined, isOptional: boolean, isStatic: boolean, isAsync: boolean, start?: number | undefined, end?: number | undefined);
+}

package/dist/modules/typescript-parser/declarations/MethodDeclaration.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodDeclaration = void 0;
+/**
+ * Method declaration. A method is contained in an interface or a class.
+ * Contains information abount the method itself.
+ *
+ * @export
+ * @class MethodDeclaration
+ * @implements {CallableDeclaration}
+ * @implements {ScopedDeclaration}
+ * @implements {TypedDeclaration}
+ */
+class MethodDeclaration {
+    constructor(name, isAbstract, visibility, type, isOptional, isStatic, isAsync, start, end) {
+        this.name = name;
+        this.isAbstract = isAbstract;
+        this.visibility = visibility;
+        this.type = type;
+        this.isOptional = isOptional;
+        this.isStatic = isStatic;
+        this.isAsync = isAsync;
+        this.start = start;
+        this.end = end;
+        this.parameters = [];
+        this.variables = [];
+    }
+}
+exports.MethodDeclaration = MethodDeclaration;

package/dist/modules/typescript-parser/declarations/ModuleDeclaration.d.ts

@@ -0,0 +1,15 @@
+import { Declaration } from './Declaration';
+/**
+ * Module (namespace) declaration. Does export a whole module or namespace that is mainly used by
+ * external declaration files.
+ *
+ * @export
+ * @class ModuleDeclaration
+ * @implements {Declaration}
+ */
+export declare class ModuleDeclaration implements Declaration {
+    name: string;
+    start?: number | undefined;
+    end?: number | undefined;
+    constructor(name: string, start?: number | undefined, end?: number | undefined);
+}

package/dist/modules/typescript-parser/declarations/ModuleDeclaration.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleDeclaration = void 0;
+/**
+ * Module (namespace) declaration. Does export a whole module or namespace that is mainly used by
+ * external declaration files.
+ *
+ * @export
+ * @class ModuleDeclaration
+ * @implements {Declaration}
+ */
+class ModuleDeclaration {
+    constructor(name, start, end) {
+        this.name = name;
+        this.start = start;
+        this.end = end;
+    }
+}
+exports.ModuleDeclaration = ModuleDeclaration;

package/dist/modules/typescript-parser/declarations/ParameterDeclaration.d.ts

@@ -0,0 +1,33 @@
+import { TypedDeclaration } from './Declaration';
+/**
+ * Parameter declaration. Is contained in a method or function delaration since a parameter can not be exported
+ * by itself.
+ *
+ * @export
+ * @class ParameterDeclaration
+ * @implements {TypedDeclaration}
+ */
+export declare class ParameterDeclaration implements TypedDeclaration {
+    name: string;
+    type: string | undefined;
+    start?: number | undefined;
+    end?: number | undefined;
+    constructor(name: string, type: string | undefined, start?: number | undefined, end?: number | undefined);
+}
+export declare class BoundParameterDeclaration extends ParameterDeclaration {
+    private startCharacter;
+    private endCharacter;
+    parameters: ParameterDeclaration[];
+    typeReference: string | undefined;
+    get name(): string;
+    set name(_: string);
+    get type(): string;
+    set type(_: string);
+    constructor(startCharacter: string, endCharacter: string, start?: number, end?: number);
+}
+export declare class ObjectBoundParameterDeclaration extends BoundParameterDeclaration {
+    constructor(start?: number, end?: number);
+}
+export declare class ArrayBoundParameterDeclaration extends BoundParameterDeclaration {
+    constructor(start?: number, end?: number);
+}

package/dist/modules/typescript-parser/declarations/ParameterDeclaration.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayBoundParameterDeclaration = exports.ObjectBoundParameterDeclaration = exports.BoundParameterDeclaration = exports.ParameterDeclaration = void 0;
+/**
+ * Parameter declaration. Is contained in a method or function delaration since a parameter can not be exported
+ * by itself.
+ *
+ * @export
+ * @class ParameterDeclaration
+ * @implements {TypedDeclaration}
+ */
+class ParameterDeclaration {
+    constructor(name, type, start, end) {
+        this.name = name;
+        this.type = type;
+        this.start = start;
+        this.end = end;
+    }
+}
+exports.ParameterDeclaration = ParameterDeclaration;
+class BoundParameterDeclaration extends ParameterDeclaration {
+    constructor(startCharacter, endCharacter, start, end) {
+        super('', '', start, end);
+        this.startCharacter = startCharacter;
+        this.endCharacter = endCharacter;
+        this.parameters = [];
+    }
+    get name() {
+        return this.parameters.length ?
+            `${this.startCharacter} ${this.parameters.map(p => p.name).join(', ')} ${this.endCharacter}` :
+            this.startCharacter + this.endCharacter;
+    }
+    set name(_) { }
+    get type() {
+        return this.typeReference ||
+            this.parameters.length ?
+            `{ ${this.parameters.map(p => p.type).join(', ')} }` :
+            this.startCharacter + this.endCharacter;
+    }
+    set type(_) { }
+}
+exports.BoundParameterDeclaration = BoundParameterDeclaration;
+class ObjectBoundParameterDeclaration extends BoundParameterDeclaration {
+    constructor(start, end) {
+        super('{', '}', start, end);
+    }
+}
+exports.ObjectBoundParameterDeclaration = ObjectBoundParameterDeclaration;
+class ArrayBoundParameterDeclaration extends BoundParameterDeclaration {
+    constructor(start, end) {
+        super('[', ']', start, end);
+    }
+}
+exports.ArrayBoundParameterDeclaration = ArrayBoundParameterDeclaration;