@alterior/runtime 3.0.0-rc.5 → 3.0.0

package/dist/reflector.js

@@ -1,494 +1,307 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Reflector = exports.Type = exports.Parameter = exports.ConstructorMethod = exports.Field = exports.Method = exports.Property = void 0;
-var tslib_1 = require("tslib");
-var annotations_1 = require("@alterior/annotations");
-var common_1 = require("@alterior/common");
+const annotations_1 = require("@alterior/annotations");
+const common_1 = require("@alterior/common");
 /**
  * Represents a property on a class. A property can also be a field or a method.
  */
-var Property = /** @class */ (function () {
-    function Property(_type, _name, _isStatic) {
-        if (_isStatic === void 0) { _isStatic = false; }
+class Property {
+    constructor(_type, _name, _isStatic = false) {
         this._type = _type;
         this._name = _name;
         this._isStatic = _isStatic;
         this._descriptor = null;
         this._visibility = _name[0] === '_' ? 'private' : 'public';
     }
-    Property.prototype.defineMetadata = function (key, value) {
+    defineMetadata(key, value) {
         Reflect.defineMetadata(key, value, this.type, this.name);
-    };
-    Property.prototype.getMetadata = function (key) {
+    }
+    getMetadata(key) {
         return Reflect.getMetadata(key, this.type, this.name);
-    };
-    Property.prototype.deleteMetadata = function (key) {
+    }
+    deleteMetadata(key) {
         Reflect.deleteMetadata(key, this.type, this.name);
-    };
-    Object.defineProperty(Property.prototype, "valueType", {
-        get: function () {
-            if (!this._valueType) {
-                var rawType = this.getMetadata('design:type');
-                if (!rawType)
-                    return undefined;
-                this._valueType = new Type(rawType);
-            }
-            return this._valueType;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Property.prototype, "isStatic", {
-        get: function () {
-            return this._isStatic;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Property.prototype, "type", {
-        get: function () {
-            return this._type;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Property.prototype, "annotations", {
-        get: function () {
-            if (!this._annotations) {
-                if (this._name === 'constructor')
-                    this._annotations = annotations_1.Annotations.getClassAnnotations(this._type);
-                else
-                    this._annotations = annotations_1.Annotations.getPropertyAnnotations(this._type, this.name, this.isStatic);
-            }
-            return this._annotations;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Property.prototype.annotationsOfType = function (type) {
+    }
+    get valueType() {
+        if (!this._valueType) {
+            let rawType = this.getMetadata('design:type');
+            if (!rawType)
+                return undefined;
+            this._valueType = new Type(rawType);
+        }
+        return this._valueType;
+    }
+    get isStatic() {
+        return this._isStatic;
+    }
+    get type() {
+        return this._type;
+    }
+    get annotations() {
+        if (!this._annotations) {
+            if (this._name === 'constructor')
+                this._annotations = annotations_1.Annotations.getClassAnnotations(this._type);
+            else
+                this._annotations = annotations_1.Annotations.getPropertyAnnotations(this._type, this.name, this.isStatic);
+        }
+        return this._annotations;
+    }
+    annotationsOfType(type) {
         return type.filter(this.annotations);
-    };
-    Property.prototype.annotationOfType = function (type) {
+    }
+    annotationOfType(type) {
         return type.filter(this.annotations)[0];
-    };
-    Object.defineProperty(Property.prototype, "descriptor", {
-        get: function () {
-            if (!this._descriptor)
-                this._descriptor = Object.getOwnPropertyDescriptor(this._type.prototype, this._name);
-            return this._descriptor;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Property.prototype, "name", {
-        get: function () {
-            return this._name;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Property.prototype, "visibility", {
-        get: function () {
-            return this._visibility;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return Property;
-}());
+    }
+    get descriptor() {
+        if (!this._descriptor)
+            this._descriptor = Object.getOwnPropertyDescriptor(this._type.prototype, this._name);
+        return this._descriptor;
+    }
+    get name() {
+        return this._name;
+    }
+    get visibility() {
+        return this._visibility;
+    }
+}
 exports.Property = Property;
 /**
  * Represents a method on a class. A method can be a static or instance method, and has a set of parameters
  * and a return type.
  */
-var Method = /** @class */ (function (_super) {
-    (0, tslib_1.__extends)(Method, _super);
-    function Method(type, name, isStatic) {
-        if (isStatic === void 0) { isStatic = false; }
-        return _super.call(this, type, name, isStatic) || this;
-    }
-    Object.defineProperty(Method.prototype, "returnType", {
-        get: function () {
-            if (!this._returnType) {
-                var rawType = this.getMetadata('design:returntype');
-                if (!rawType)
-                    return undefined;
-                this._returnType = new Type(rawType);
-            }
-            return this._returnType;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Method.prototype, "parameterTypes", {
-        get: function () {
-            if (!this._parameterTypes) {
-                var rawTypes = this.getMetadata('design:paramtypes');
-                this._parameterTypes = rawTypes.map(function (x) { return x ? new Type(x) : undefined; });
-            }
-            return this._parameterTypes;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Method.prototype, "implementation", {
-        get: function () {
-            return this.type[this.name];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Method.prototype, "parameterNames", {
-        get: function () {
-            if (!this._parameterNames)
-                this._parameterNames = (0, common_1.getParameterNames)(this.implementation);
-            return this._parameterNames;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Method.prototype, "parameters", {
-        get: function () {
-            var _this = this;
-            var parameterNames = this.parameterNames;
-            return (0, tslib_1.__spreadArray)([], (0, tslib_1.__read)(Array(this.implementation.length).keys()), false).map(function (i) { return new Parameter(_this, i, parameterNames[i]); });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Method.prototype, "parameterAnnotations", {
-        get: function () {
-            if (!this._parameterAnnotations)
-                this._parameterAnnotations = annotations_1.Annotations.getParameterAnnotations(this.type, this.name);
-            return this._parameterAnnotations;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return Method;
-}(Property));
+class Method extends Property {
+    constructor(type, name, isStatic = false) {
+        super(type, name, isStatic);
+    }
+    get returnType() {
+        if (!this._returnType) {
+            let rawType = this.getMetadata('design:returntype');
+            if (!rawType)
+                return undefined;
+            this._returnType = new Type(rawType);
+        }
+        return this._returnType;
+    }
+    get parameterTypes() {
+        if (!this._parameterTypes) {
+            let rawTypes = this.getMetadata('design:paramtypes');
+            this._parameterTypes = rawTypes.map(x => x ? new Type(x) : undefined);
+        }
+        return this._parameterTypes;
+    }
+    get implementation() {
+        return this.type[this.name];
+    }
+    get parameterNames() {
+        if (!this._parameterNames)
+            this._parameterNames = (0, common_1.getParameterNames)(this.implementation);
+        return this._parameterNames;
+    }
+    get parameters() {
+        let parameterNames = this.parameterNames;
+        return [...Array(this.implementation.length).keys()]
+            .map(i => new Parameter(this, i, parameterNames[i]));
+    }
+    get parameterAnnotations() {
+        if (!this._parameterAnnotations)
+            this._parameterAnnotations = annotations_1.Annotations.getParameterAnnotations(this.type, this.name);
+        return this._parameterAnnotations;
+    }
+}
 exports.Method = Method;
-var Field = /** @class */ (function (_super) {
-    (0, tslib_1.__extends)(Field, _super);
-    function Field(type, name, isStatic) {
-        if (isStatic === void 0) { isStatic = false; }
-        return _super.call(this, type, name, isStatic) || this;
-    }
-    return Field;
-}(Property));
+class Field extends Property {
+    constructor(type, name, isStatic = false) {
+        super(type, name, isStatic);
+    }
+}
 exports.Field = Field;
-var ConstructorMethod = /** @class */ (function (_super) {
-    (0, tslib_1.__extends)(ConstructorMethod, _super);
-    function ConstructorMethod(type) {
-        return _super.call(this, type, 'constructor') || this;
-    }
-    Object.defineProperty(ConstructorMethod.prototype, "parameterAnnotations", {
-        get: function () {
-            if (!this._ctorParameterAnnotations)
-                this._ctorParameterAnnotations = annotations_1.Annotations.getConstructorParameterAnnotations(this.type);
-            return this._ctorParameterAnnotations;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return ConstructorMethod;
-}(Method));
+class ConstructorMethod extends Method {
+    constructor(type) {
+        super(type, 'constructor');
+    }
+    get parameterAnnotations() {
+        if (!this._ctorParameterAnnotations)
+            this._ctorParameterAnnotations = annotations_1.Annotations.getConstructorParameterAnnotations(this.type);
+        return this._ctorParameterAnnotations;
+    }
+}
 exports.ConstructorMethod = ConstructorMethod;
-var Parameter = /** @class */ (function () {
-    function Parameter(_method, _index, _name) {
-        if (_name === void 0) { _name = null; }
+class Parameter {
+    constructor(_method, _index, _name = null) {
         this._method = _method;
         this._index = _index;
         this._name = _name;
     }
-    Object.defineProperty(Parameter.prototype, "annotations", {
-        get: function () {
-            return this.method.parameterAnnotations[this.index];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Parameter.prototype.annotationsOfType = function (type) {
+    get annotations() {
+        return this.method.parameterAnnotations[this.index];
+    }
+    annotationsOfType(type) {
         return type.filter(this.annotations);
-    };
-    Parameter.prototype.annotationOfType = function (type) {
+    }
+    annotationOfType(type) {
         return type.filter(this.annotations)[0];
-    };
-    Object.defineProperty(Parameter.prototype, "method", {
-        get: function () {
-            return this._method;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Parameter.prototype, "valueType", {
-        get: function () {
-            return this.method.parameterTypes[this.index];
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Parameter.prototype, "index", {
-        get: function () {
-            return this._index;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Parameter.prototype, "name", {
-        get: function () {
-            return this._name;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return Parameter;
-}());
+    }
+    get method() {
+        return this._method;
+    }
+    get valueType() {
+        return this.method.parameterTypes[this.index];
+    }
+    get index() {
+        return this._index;
+    }
+    get name() {
+        return this._name;
+    }
+}
 exports.Parameter = Parameter;
 /**
  * Represents a class Type and it's metadata
  */
-var Type = /** @class */ (function () {
-    function Type(_class) {
+class Type {
+    constructor(_class) {
         this._class = _class;
         this._staticPropertyNames = [];
         this._staticMethodNames = [];
         this._staticFieldNames = [];
     }
-    Object.defineProperty(Type.prototype, "name", {
-        get: function () {
-            return this._class.name;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Type.prototype.getMetadata = function (key) {
+    get name() {
+        return this._class.name;
+    }
+    getMetadata(key) {
         Reflect.getOwnMetadata(key, this._class);
-    };
-    Type.prototype.defineMetadata = function (key, value) {
+    }
+    defineMetadata(key, value) {
         Reflect.defineMetadata(key, value, this._class.prototype);
-    };
-    Type.prototype.deleteMetadata = function (key) {
+    }
+    deleteMetadata(key) {
         Reflect.deleteMetadata(key, this._class);
-    };
-    Object.defineProperty(Type.prototype, "metadataKeys", {
-        get: function () {
-            if (!this._metadataKeys)
-                this._metadataKeys = Reflect.getOwnMetadataKeys(this._class);
-            return this._metadataKeys;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Type.prototype, "annotations", {
-        /**
-         * Get all annotations attached to this class
-         */
-        get: function () {
-            if (!this._annotations)
-                this._annotations = annotations_1.Annotations.getClassAnnotations(this._class);
-            return this._annotations;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Type.prototype.annotationsOfType = function (type) {
+    }
+    get metadataKeys() {
+        if (!this._metadataKeys)
+            this._metadataKeys = Reflect.getOwnMetadataKeys(this._class);
+        return this._metadataKeys;
+    }
+    /**
+     * Get all annotations attached to this class
+     */
+    get annotations() {
+        if (!this._annotations)
+            this._annotations = annotations_1.Annotations.getClassAnnotations(this._class);
+        return this._annotations;
+    }
+    annotationsOfType(type) {
         return type.filter(this.annotations);
-    };
-    Type.prototype.annotationOfType = function (type) {
+    }
+    annotationOfType(type) {
         return type.filter(this.annotations)[0];
-    };
-    Type.prototype.fetchPropertyNames = function () {
-        var e_1, _a;
+    }
+    fetchPropertyNames() {
         this._propertyNames = Object.getOwnPropertyNames(this._class.prototype);
-        try {
-            for (var _b = (0, tslib_1.__values)(this._propertyNames), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var propertyName = _c.value;
-                if (typeof this._class.prototype[propertyName] === 'function') {
-                    this._methodNames.push(propertyName);
-                }
-                else {
-                    this._fieldNames.push(propertyName);
-                }
+        for (let propertyName of this._propertyNames) {
+            if (typeof this._class.prototype[propertyName] === 'function') {
+                this._methodNames.push(propertyName);
             }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            else {
+                this._fieldNames.push(propertyName);
             }
-            finally { if (e_1) throw e_1.error; }
         }
-    };
-    Type.prototype.fetchStaticPropertyNames = function () {
-        var e_2, _a;
-        this._staticPropertyNames = Object.getOwnPropertyNames(this._class).filter(function (x) { return !['length', 'prototype', 'name'].includes(x); });
-        try {
-            for (var _b = (0, tslib_1.__values)(this._staticPropertyNames), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var propertyName = _c.value;
-                if (typeof this._class[propertyName] === 'function') {
-                    this._staticMethodNames.push(propertyName);
-                }
-                else {
-                    this._staticFieldNames.push(propertyName);
-                }
+    }
+    fetchStaticPropertyNames() {
+        this._staticPropertyNames = Object.getOwnPropertyNames(this._class).filter(x => !['length', 'prototype', 'name'].includes(x));
+        for (let propertyName of this._staticPropertyNames) {
+            if (typeof this._class[propertyName] === 'function') {
+                this._staticMethodNames.push(propertyName);
             }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            else {
+                this._staticFieldNames.push(propertyName);
             }
-            finally { if (e_2) throw e_2.error; }
         }
-    };
-    Object.defineProperty(Type.prototype, "staticPropertyNames", {
-        get: function () {
-            if (!this._staticPropertyNames)
-                this.fetchStaticPropertyNames();
-            return this._staticPropertyNames.slice();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Type.prototype, "staticMethodNames", {
-        get: function () {
-            if (!this._staticPropertyNames)
-                this.fetchStaticPropertyNames();
-            return this._staticMethodNames.slice();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Type.prototype, "staticFieldNames", {
-        get: function () {
-            if (!this._staticPropertyNames)
-                this.fetchStaticPropertyNames();
-            return this._staticFieldNames.slice();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Type.prototype, "staticMethods", {
-        get: function () {
-            var _this = this;
-            if (this._staticMethods)
-                return this._staticMethods;
-            this._staticMethods = this.staticMethodNames.map(function (methodName) { return new Method(_this._class, methodName, true); });
+    }
+    get staticPropertyNames() {
+        if (!this._staticPropertyNames)
+            this.fetchStaticPropertyNames();
+        return this._staticPropertyNames.slice();
+    }
+    get staticMethodNames() {
+        if (!this._staticPropertyNames)
+            this.fetchStaticPropertyNames();
+        return this._staticMethodNames.slice();
+    }
+    get staticFieldNames() {
+        if (!this._staticPropertyNames)
+            this.fetchStaticPropertyNames();
+        return this._staticFieldNames.slice();
+    }
+    get staticMethods() {
+        if (this._staticMethods)
             return this._staticMethods;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Type.prototype, "staticFields", {
-        get: function () {
-            var _this = this;
-            if (this._staticFields)
-                return this._staticFields;
-            this._staticFields = this.staticFieldNames.map(function (fieldName) { return new Field(_this._class, fieldName, true); });
+        this._staticMethods = this.staticMethodNames.map(methodName => new Method(this._class, methodName, true));
+        return this._staticMethods;
+    }
+    get staticFields() {
+        if (this._staticFields)
             return this._staticFields;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Type.prototype, "staticProperties", {
-        get: function () {
-            if (this._staticProperties)
-                return this._staticProperties;
-            this._staticProperties = [].concat(this.staticFields, this.staticMethods);
+        this._staticFields = this.staticFieldNames.map(fieldName => new Field(this._class, fieldName, true));
+        return this._staticFields;
+    }
+    get staticProperties() {
+        if (this._staticProperties)
             return this._staticProperties;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Type.prototype, "propertyNames", {
-        get: function () {
-            if (!this._propertyNames)
-                this.fetchPropertyNames();
-            return this._propertyNames.slice();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Type.prototype, "methodNames", {
-        get: function () {
-            if (!this._propertyNames)
-                this.fetchPropertyNames();
-            return this._methodNames.slice();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Type.prototype, "fieldNames", {
-        get: function () {
-            if (!this._propertyNames)
-                this.fetchPropertyNames();
-            return this._fieldNames.slice();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Type.prototype, "constructorMethod", {
-        get: function () {
-            if (!this._ctor)
-                this._ctor = new ConstructorMethod(this._class);
-            return this._ctor;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Type.prototype, "methods", {
-        get: function () {
-            var _this = this;
-            if (this._methods)
-                return this._methods;
-            this._methods = this.methodNames.map(function (methodName) { return new Method(_this._class, methodName); });
+        this._staticProperties = [].concat(this.staticFields, this.staticMethods);
+        return this._staticProperties;
+    }
+    get propertyNames() {
+        if (!this._propertyNames)
+            this.fetchPropertyNames();
+        return this._propertyNames.slice();
+    }
+    get methodNames() {
+        if (!this._propertyNames)
+            this.fetchPropertyNames();
+        return this._methodNames.slice();
+    }
+    get fieldNames() {
+        if (!this._propertyNames)
+            this.fetchPropertyNames();
+        return this._fieldNames.slice();
+    }
+    get constructorMethod() {
+        if (!this._ctor)
+            this._ctor = new ConstructorMethod(this._class);
+        return this._ctor;
+    }
+    get methods() {
+        if (this._methods)
             return this._methods;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Type.prototype, "properties", {
-        get: function () {
-            if (this._properties)
-                return this._properties;
-            this._properties = [].concat(this.fields, this.methods);
+        this._methods = this.methodNames.map(methodName => new Method(this._class, methodName));
+        return this._methods;
+    }
+    get properties() {
+        if (this._properties)
             return this._properties;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Type.prototype, "fields", {
-        get: function () {
-            var _this = this;
-            if (this._fields)
-                return this._fields;
-            this._fields = this.fieldNames.map(function (fieldName) { return new Field(_this._class, fieldName); });
+        this._properties = [].concat(this.fields, this.methods);
+        return this._properties;
+    }
+    get fields() {
+        if (this._fields)
             return this._fields;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Type.prototype, "base", {
-        get: function () {
-            return new Type(Object.getPrototypeOf(this._class));
-        },
-        enumerable: false,
-        configurable: true
-    });
-    return Type;
-}());
-exports.Type = Type;
-var Reflector = /** @class */ (function () {
-    function Reflector() {
+        this._fields = this.fieldNames.map(fieldName => new Field(this._class, fieldName));
+        return this._fields;
     }
-    Reflector.prototype.getTypeFromInstance = function (instance) {
+    get base() {
+        return new Type(Object.getPrototypeOf(this._class));
+    }
+}
+exports.Type = Type;
+class Reflector {
+    getTypeFromInstance(instance) {
         return this.getTypeFromClass(instance.constructor);
-    };
-    Reflector.prototype.getTypeFromClass = function (typeClass) {
+    }
+    getTypeFromClass(typeClass) {
         return new Type(typeClass);
-    };
-    return Reflector;
-}());
+    }
+}
 exports.Reflector = Reflector;
 //# sourceMappingURL=reflector.js.map