@dipscope/type-manager/dist/es5/metadata.js

Transform JSON strings or plain objects into JS class instances.

import { EMPTY_ARRAY } from './constants/empty-array';
import { Unknown } from './unknown';
var Metadata = (function () {
    function Metadata(typeManager, typeFnMap) {
        this.typeManager = typeManager;
        this.typeFnMap = typeFnMap;
        return;
    }
    Metadata.prototype.resolveTypeMetadatas = function (typeArguments) {
        var typeMetadatas = new Array(typeArguments.length);
        for (var i = 0; i < typeArguments.length; i++) {
            typeMetadatas[i] = this.resolveTypeMetadata(typeArguments[i]);
        }
        return typeMetadatas;
    };
    Metadata.prototype.resolveTypeMetadata = function (typeArgument) {
        if (typeof typeArgument === 'function') {
            if (typeArgument.name === '') {
                return this.resolveTypeMetadataUsingTypeResolver(typeArgument);
            }
            return this.resolveTypeMetadataUsingTypeFn(typeArgument);
        }
        if (typeof typeArgument === 'string') {
            return this.resolveTypeMetadataUsingAlias(typeArgument);
        }
        return this.resolveTypeMetadataUsingUnknownTypeFn();
    };
    Metadata.prototype.resolveTypeMetadataUsingTypeResolver = function (typeArgument) {
        var typeResolver = typeArgument;
        return this.typeManager.extractTypeMetadata(typeResolver());
    };
    Metadata.prototype.resolveTypeMetadataUsingTypeFn = function (typeArgument) {
        var typeFn = typeArgument;
        return this.typeManager.extractTypeMetadata(typeFn);
    };
    Metadata.prototype.resolveTypeMetadataUsingAlias = function (typeArgument) {
        var alias = typeArgument;
        var typeFn = this.typeFnMap.get(alias);
        if (typeFn === undefined) {
            this.typeManager.logger.error('Metadata', 'Cannot resolve type metadata for provided type alias.', alias);
            this.typeManager.logger.info('Metadata', 'Check if a type exists that defines such an alias. In the meantime, metadata for an unknown type will be used.');
            return this.resolveTypeMetadataUsingUnknownTypeFn();
        }
        return this.typeManager.extractTypeMetadata(typeFn);
    };
    Metadata.prototype.resolveTypeMetadataUsingUnknownTypeFn = function () {
        var typeFn = Unknown;
        return this.typeManager.extractTypeMetadata(typeFn);
    };
    Metadata.prototype.resolveGenericMetadatas = function (genericArguments) {
        var genericMetadatas = new Array(genericArguments.length);
        for (var i = 0; i < genericArguments.length; i++) {
            var genericArgument = genericArguments[i];
            if (Array.isArray(genericArgument)) {
                genericMetadatas[i] = [
                    this.resolveTypeMetadata(genericArgument[0]),
                    this.resolveGenericMetadatas(genericArgument[1])
                ];
                continue;
            }
            genericMetadatas[i] = [
                this.resolveTypeMetadata(genericArgument),
                EMPTY_ARRAY
            ];
        }
        return genericMetadatas;
    };
    return Metadata;
}());
export { Metadata };
//# sourceMappingURL=metadata.js.map