@oracle/oraclejet 11.0.6 → 11.1.1

package/dist/custom-tsc/utils/MetadataPropertyUtils.js

@@ -32,7 +32,7 @@ function generatePropertiesMetadata(propsInfo, metaUtilObj) {
     let readOnlyProps = [];
     let writebackProps = [];
     let propsName = propsInfo.propsName;
-    MetaUtils.walkTypeMembers(propsInfo.propsType, metaUtilObj.typeChecker, (memberSymbol, memberKey) => {
+    MetaUtils.walkTypeMembers(propsInfo.propsType, metaUtilObj, (memberSymbol, memberKey, mappedTypeSymbol) => {
         if (!TypeUtils.isGenericTypeParameter(memberSymbol)) {
             const propDeclaration = memberSymbol.valueDeclaration;
             const prop = memberKey;
@@ -47,8 +47,8 @@ function generatePropertiesMetadata(propsInfo, metaUtilObj) {
                     metaUtilObj.rtMetadata.properties = {};
                     metaUtilObj.fullMetadata.properties = {};
                 }
-                const rt = getMetadataForProperty(prop, memberSymbol, propDeclaration, propsName, MetaTypes.MetadataScope.RT, metaUtilObj);
-                const dt = getMetadataForProperty(prop, memberSymbol, propDeclaration, propsName, MetaTypes.MetadataScope.DT, metaUtilObj);
+                const rt = getMetadataForProperty(prop, memberSymbol, propDeclaration, mappedTypeSymbol, propsName, MetaTypes.MetadataScope.RT, metaUtilObj);
+                const dt = getMetadataForProperty(prop, memberSymbol, propDeclaration, mappedTypeSymbol, propsName, MetaTypes.MetadataScope.DT, metaUtilObj);
                 metaUtilObj.rtMetadata.properties[prop] = rt;
                 metaUtilObj.fullMetadata.properties[prop] = dt;
                 if (typeName === `${metaUtilObj.namedExportToAlias.ElementReadOnly}`) {
@@ -63,8 +63,7 @@ function generatePropertiesMetadata(propsInfo, metaUtilObj) {
 }
 exports.generatePropertiesMetadata = generatePropertiesMetadata;
 function checkReservedProps(propsInfo, metaUtilObj) {
-    const checker = metaUtilObj.typeChecker;
-    MetaUtils.walkTypeMembers(propsInfo.propsType, checker, (memberSymbol, memberKey) => {
+    MetaUtils.walkTypeMembers(propsInfo.propsType, metaUtilObj, (memberSymbol, memberKey, mappedTypeSymbol) => {
         var _a;
         if (TypeUtils.isGenericTypeParameter(memberSymbol)) {
             return;
@@ -125,7 +124,7 @@ function getWritebackPropName(prop, typeName, metaUtilObj) {
     }
     return null;
 }
-function getMetadataForProperty(prop, memberSymbol, propDeclaration, propsName, scope, metaUtilObj) {
+function getMetadataForProperty(prop, memberSymbol, propDeclaration, mappedTypeSymbol, propsName, scope, metaUtilObj) {
     let md;
     const metaObj = TypeUtils.getAllMetadataForDeclaration(propDeclaration, scope, metaUtilObj);
     let stack = [];
@@ -135,7 +134,8 @@ function getMetadataForProperty(prop, memberSymbol, propDeclaration, propsName,
     const subprops = TypeUtils.getComplexPropertyMetadata(memberSymbol, metaObj.type, propsName, scope, stack, metaUtilObj);
     md = metaObj;
     if (scope == MetaTypes.MetadataScope.DT) {
-        md["optional"] = propDeclaration["questionToken"] ? true : false;
+        const propSym = mappedTypeSymbol !== null && mappedTypeSymbol !== void 0 ? mappedTypeSymbol : memberSymbol;
+        md["optional"] = propSym.flags & ts.SymbolFlags.Optional ? true : false;
     }
     if (subprops) {
         if (subprops.circRefDetected) {
@@ -182,11 +182,18 @@ function isDefaultProps(node) {
 }
 exports.isDefaultProps = isDefaultProps;
 function updateDefaultsFromDefaultProps(defaultProps, metaUtilObj) {
-    const fullPropsMeta = metaUtilObj.fullMetadata.properties;
+    var _a;
+    const fullPropsMeta = (_a = metaUtilObj.fullMetadata) === null || _a === void 0 ? void 0 : _a.properties;
     defaultProps.properties.forEach((prop) => {
         if (ts.isPropertyAssignment(prop)) {
-            const propertyName = prop.name.getText();
-            updateDefaultValue(fullPropsMeta[propertyName], propertyName, prop, metaUtilObj);
+            const propName = prop.name.getText();
+            const propMetadata = fullPropsMeta === null || fullPropsMeta === void 0 ? void 0 : fullPropsMeta[propName];
+            if (propMetadata) {
+                updateDefaultValue(propMetadata, propName, prop, metaUtilObj);
+            }
+            else {
+                reportInvalidDefaultPropsDefault(propName, metaUtilObj);
+            }
         }
     });
 }
@@ -219,3 +226,23 @@ function updateDefaultValue(md, propertyName, propDeclaration, metaUtilObj) {
         }
     }
 }
+function reportInvalidDefaultPropsDefault(propName, metaUtilObj) {
+    var _a, _b;
+    const fullMeta = metaUtilObj.fullMetadata;
+    let errMsg;
+    if (propName === MetaTypes.DEFAULT_SLOT_PROP || ((_a = fullMeta.slots) === null || _a === void 0 ? void 0 : _a[propName])) {
+        return;
+    }
+    else {
+        if (propName.length > 2) {
+            const eventPropName = `${propName[2].toLowerCase()}${propName.substring(3)}`;
+            if ((_b = fullMeta.events) === null || _b === void 0 ? void 0 : _b[eventPropName]) {
+                errMsg = `The '${propName}' event handler cannot be initialized through defaultProps.`;
+            }
+        }
+        if (!errMsg) {
+            errMsg = `Unknown property '${propName}' cannot be initialized through defaultProps.`;
+        }
+    }
+    throw new TransformerError_1.TransformerError(metaUtilObj.componentClassName, errMsg);
+}

package/dist/custom-tsc/utils/MetadataSlotUtils.js

@@ -127,17 +127,16 @@ function getDtMetadataForSlot(propDeclaration, metaUtilObj) {
 }
 function getSlotData(detailNode, metaUtilObj) {
     let data = {};
-    const checker = metaUtilObj.typeChecker;
     let detailName;
     if (ts.isTypeReferenceNode(detailNode)) {
         detailName = TypeUtils.getTypeNameFromTypeReference(detailNode);
     }
-    MetaUtils.walkTypeNodeMembers(detailNode, checker, (value, key) => {
-        const propSignature = value.valueDeclaration;
+    MetaUtils.walkTypeNodeMembers(detailNode, metaUtilObj, (symbol, key, mappedTypeSymbol) => {
+        const propSignature = symbol.valueDeclaration;
         if (!propSignature) {
             return;
         }
-        const symbolType = metaUtilObj.typeChecker.getTypeOfSymbolAtLocation(value, propSignature);
+        const symbolType = metaUtilObj.typeChecker.getTypeOfSymbolAtLocation(symbol, propSignature);
         if (ts.isPropertySignature(propSignature) ||
             ts.isPropertyDeclaration(propSignature)) {
             const property = key.toString();
@@ -149,7 +148,7 @@ function getSlotData(detailNode, metaUtilObj) {
                 if (slotDataMetadata.type === "Array<object>") {
                     stack.push(key);
                 }
-                const subprops = TypeUtils.getComplexPropertyMetadata(value, slotDataMetadata.type, detailName, MetaTypes.MetadataScope.DT, stack, metaUtilObj);
+                const subprops = TypeUtils.getComplexPropertyMetadata(symbol, slotDataMetadata.type, detailName, MetaTypes.MetadataScope.DT, stack, metaUtilObj);
                 if (subprops) {
                     if (subprops.circRefDetected) {
                         data[property].type = TypeUtils.getSubstituteTypeForCircularReference(slotDataMetadata);

package/dist/custom-tsc/utils/MetadataTypeUtils.js

@@ -23,7 +23,7 @@ exports.getEnumStringsFromUnion = exports.isClassDeclaration = exports.possibleC
 const ts = __importStar(require("typescript"));
 const MetaTypes = __importStar(require("./MetadataTypes"));
 const MetaUtils = __importStar(require("./MetadataUtils"));
-const _REGEX_EXTRA_WHITESPACE = new RegExp(/\s\s+/g);
+const _REGEX_EXTRA_WHITESPACE = new RegExp(/\s\s*/g);
 const _OR_NULL = "|null";
 function getGenericsAndTypeParameters(node, isPropsClass) {
     var _a;
@@ -250,7 +250,10 @@ function getTypeReferenceNodeSignature(node, isPropSignature, metaUtilObj) {
     let refNodeTypeName = typeRefNode.typeName.getText();
     const typeObject = metaUtilObj.typeChecker.getTypeAtLocation(typeRefNode);
     const strType = metaUtilObj.typeChecker.typeToString(typeObject);
-    if (typeRefNode.typeArguments) {
+    if (MetaUtils.isMappedType(typeObject)) {
+        refNodeTypeName = strType;
+    }
+    else if (typeRefNode.typeArguments) {
         refNodeTypeName += MetaUtils.getGenericTypeParameters(typeRefNode);
     }
     let typeObj = {
@@ -813,7 +816,7 @@ const _NON_OBJECT_TYPES = new Set([
 ]);
 function possibleComplexProperty(symbolType, type, scope) {
     let iscomplex = true;
-    if (!symbolType.isIntersection()) {
+    if (!(symbolType.isIntersection() || MetaUtils.isMappedType(symbolType))) {
         if (_NON_OBJECT_TYPES.has(type) ||
             isDomType(symbolType) ||
             isClassDeclaration(symbolType) ||
@@ -917,25 +920,29 @@ function getComplexPropertyHelper(memberSymbol, type, seen, scope, stack, metaUt
                 if (ts.isIndexedAccessTypeNode(typeRefNode)) {
                     const typeObject = getSymbolTypeFromIndexedAccessTypeNode(typeRefNode, metaUtilObj);
                     if (typeObject) {
-                        type = !isTypeLiteralType(typeObject)
-                            ? getTypeNameFromType(typeObject)
-                            : "object";
                         symbolType = typeObject;
+                        type = !isTypeLiteralType(symbolType)
+                            ? MetaUtils.isMappedType(symbolType)
+                                ? metaUtilObj.typeChecker.typeToString(symbolType)
+                                : getTypeNameFromType(symbolType)
+                            : "object";
                     }
                     else {
                         return {};
                     }
                 }
                 else {
+                    symbolType = metaUtilObj.typeChecker.getTypeAtLocation(typeRefNode);
                     if (!ts.isTypeLiteralNode(typeRefNode)) {
-                        type = ts.isTypeReferenceNode(typeRefNode)
-                            ? getTypeNameFromTypeReference(typeRefNode)
-                            : typeRefNode.getText();
+                        type = MetaUtils.isMappedType(symbolType)
+                            ? metaUtilObj.typeChecker.typeToString(symbolType)
+                            : ts.isTypeReferenceNode(typeRefNode)
+                                ? getTypeNameFromTypeReference(typeRefNode)
+                                : typeRefNode.getText();
                     }
                     else {
                         type = "object";
                     }
-                    symbolType = metaUtilObj.typeChecker.getTypeAtLocation(typeRefNode);
                 }
             }
             else {
@@ -961,7 +968,7 @@ function getComplexPropertyHelper(memberSymbol, type, seen, scope, stack, metaUt
     }
     let processedMembers = 0;
     const metadata = {};
-    MetaUtils.walkTypeMembers(symbolType, metaUtilObj.typeChecker, (symbol, key) => {
+    MetaUtils.walkTypeMembers(symbolType, metaUtilObj, (symbol, key, mappedTypeSymbol) => {
         var _a, _b;
         if (processedMembers < 0) {
             return;
@@ -989,9 +996,9 @@ function getComplexPropertyHelper(memberSymbol, type, seen, scope, stack, metaUt
         }
         else {
             if (scope == MetaTypes.MetadataScope.DT) {
-                metaObj.optional = symbol.valueDeclaration["questionToken"]
-                    ? true
-                    : false;
+                const propSym = mappedTypeSymbol !== null && mappedTypeSymbol !== void 0 ? mappedTypeSymbol : symbol;
+                metaObj.optional =
+                    propSym.flags & ts.SymbolFlags.Optional ? true : false;
             }
             let isExtensionMd = false;
             if (scope == MetaTypes.MetadataScope.DT && metaObj.isArrayOfObject) {

package/dist/custom-tsc/utils/MetadataTypes.d.ts

@@ -75,11 +75,21 @@ export declare type HasTypeParameters = ts.ClassLikeDeclarationBase | ts.Interfa
 export declare type PropsInfo = {
     propsName: string;
     propsType: ts.Type;
+    propsMappedTypes: Array<MappedTypeItem>;
     propsExtendGlobalPropsRef: ts.TypeReferenceType | null;
     propsTypeParams?: string;
     propsGenericsDeclaration?: ts.Declaration;
     propsObservedGlobalProps?: Array<string>;
 };
+export declare type MappedTypeItem = {
+    name: string;
+    params?: string;
+};
+export declare type MappedTypesInfo = {
+    mappedTypes: Array<MappedTypeItem>;
+    wrappedTypeName: string;
+    wrappedTypeNode?: ts.TypeNode;
+};
 export declare type IntersectionTypeNodeInfo = {
     observedProps?: Array<string>;
     substituteTypeNode?: ts.TypeNode;
@@ -98,6 +108,8 @@ export declare type MetaUtilObj = {
     aliasToNamedExport: Record<string, string>;
     dynamicSlotsInUse: number;
     reservedGlobalProps?: Array<string>;
+    excludedTypes?: Set<string>;
+    excludedTypeAliases?: Set<string>;
     classConsumedBindingsDecorator?: ts.Decorator;
     classProvidedBindingsDecorator?: ts.Decorator;
 };

package/dist/custom-tsc/utils/MetadataUtils.d.ts

@@ -9,8 +9,13 @@ export declare function getDtMetadata(objWithJsDoc: ts.HasJSDoc, metaUtilObj: Me
 export declare function addMetadataToClassNode(classNode: ts.ClassDeclaration, metadata: MetaTypes.RuntimeMetadata): ts.ClassDeclaration;
 export declare function getPropsInfo(typeRef: ts.TypeReferenceNode, vexportToAlias: MetaTypes.DecoratorAliases, checker: ts.TypeChecker): MetaTypes.PropsInfo | null;
 export declare function getIntersectionTypeNodeInfo(intersectionTypeNode: ts.IntersectionTypeNode, vexportToAlias: MetaTypes.DecoratorAliases, isInline: boolean, checker: ts.TypeChecker): MetaTypes.IntersectionTypeNodeInfo;
-export declare function walkTypeMembers(type: ts.Type, checker: ts.TypeChecker, callback: (memberSymbol: ts.Symbol, memberKey: ts.__String) => void): void;
-export declare function walkTypeNodeMembers(typeNode: ts.TypeNode, checker: ts.TypeChecker, callback: (memberSymbol: ts.Symbol, memberKey: ts.__String) => void): void;
+export declare function getMappedTypesInfo(outerType: ts.Type, checker: ts.TypeChecker, isPropsInfo: boolean, outerTypeNode?: ts.TypeNode): MetaTypes.MappedTypesInfo | null;
+export declare function isPropsMappedType(type: ts.Type, typeNode?: ts.TypeNode): boolean;
+export declare function isAliasToMappedType(type: ts.Type, typeNode: ts.TypeNode): boolean;
+export declare function constructMappedTypeName(mappedTypesInfo: MetaTypes.MappedTypesInfo, wrappedTypeGenerics?: string): string;
+export declare function isMappedType(type: ts.Type): boolean;
+export declare function walkTypeMembers(type: ts.Type, metaUtilObj: MetaTypes.MetaUtilObj, callback: (memberSymbol: ts.Symbol, memberKey: ts.__String, mappedTypeSymbol?: ts.Symbol) => void): void;
+export declare function walkTypeNodeMembers(typeNode: ts.TypeNode, metaUtilObj: MetaTypes.MetaUtilObj, callback: (memberSymbol: ts.Symbol, memberKey: ts.__String, mappedTypeSymbol?: ts.Symbol) => void): void;
 export declare function updateCompilerPropsMetadata(propsInfo: MetaTypes.PropsInfo, readOnlyProps: string[], metaUtilObj: MetaTypes.MetaUtilObj): void;
 export declare function updateCompilerClassMetadata(classNode: ts.ClassDeclaration, metaUtilObj: MetaTypes.MetaUtilObj): void;
 export declare function pruneCompilerMetadata(metaUtilObj: MetaTypes.MetaUtilObj): void;

package/dist/custom-tsc/utils/MetadataUtils.js

@@ -19,7 +19,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateRtExtensionMetadata = exports.pruneMetadata = exports.pruneCompilerMetadata = exports.updateCompilerClassMetadata = exports.updateCompilerPropsMetadata = exports.walkTypeNodeMembers = exports.walkTypeMembers = exports.getIntersectionTypeNodeInfo = exports.getPropsInfo = exports.addMetadataToClassNode = exports.getDtMetadata = exports.getTypeParametersFromType = exports.getGenericTypeParameters = exports.stringToJS = exports.writebackCallbackToProperty = exports.tagNameToElementInterfaceName = void 0;
+exports.updateRtExtensionMetadata = exports.pruneMetadata = exports.pruneCompilerMetadata = exports.updateCompilerClassMetadata = exports.updateCompilerPropsMetadata = exports.walkTypeNodeMembers = exports.walkTypeMembers = exports.isMappedType = exports.constructMappedTypeName = exports.isAliasToMappedType = exports.isPropsMappedType = exports.getMappedTypesInfo = exports.getIntersectionTypeNodeInfo = exports.getPropsInfo = exports.addMetadataToClassNode = exports.getDtMetadata = exports.getTypeParametersFromType = exports.getGenericTypeParameters = exports.stringToJS = exports.writebackCallbackToProperty = exports.tagNameToElementInterfaceName = void 0;
 const ts = __importStar(require("typescript"));
 const DecoratorUtils = __importStar(require("./DecoratorUtils"));
 const TypeUtils = __importStar(require("./MetadataTypeUtils"));
@@ -118,7 +118,8 @@ function getDtMetadata(objWithJsDoc, metaUtilObj) {
     let dt = {};
     let tags = ts.getJSDocTags(objWithJsDoc);
     tags.forEach((tag) => {
-        if (tag.tagName.getText() === _METADATA_TAG) {
+        if (!ts.isJSDocDeprecatedTag(tag) &&
+            tag.tagName.getText() === _METADATA_TAG) {
             let [mdKey, mdVal] = _getDtMetadataNameValue(tag, metaUtilObj);
             let isClassMetadata = ts.isClassDeclaration(objWithJsDoc);
             if (mdKey === "styleVariableSet") {
@@ -177,12 +178,11 @@ exports.addMetadataToClassNode = addMetadataToClassNode;
 function getPropsInfo(typeRef, vexportToAlias, checker) {
     var _a, _b, _c;
     let rtnInfo = null;
-    let rtnIsIntersectionType = false;
-    let rtnIsTypeLiteral = false;
-    let rtnIsObservedGlobalPropsOnly = false;
     let rtnObservedGlobalProps = [];
+    let rtnMappedTypes = [];
     let rtnTypeNode;
     let rtnEGPRef = null;
+    let isAliasToEGP = false;
     let propsTypeParamsNode;
     let propsTypeSubstituteName;
     let typeRefName = TypeUtils.getTypeNameFromTypeReference(typeRef);
@@ -192,6 +192,7 @@ function getPropsInfo(typeRef, vexportToAlias, checker) {
         propsTypeParamsNode = rtnTypeNode;
     }
     else {
+        isAliasToEGP = true;
         propsTypeParamsNode = typeRef;
         propsTypeSubstituteName = typeRefName;
         const typeRefType = checker.getTypeAtLocation(typeRef);
@@ -233,6 +234,8 @@ function getPropsInfo(typeRef, vexportToAlias, checker) {
     if (rtnTypeNode) {
         let intersectionInlinePropsInfo;
         let rtnIsInlineIntersectionType = false;
+        let rtnIsObservedGlobalPropsOnly = false;
+        let mappedTypeGenericsDeclaration;
         if (ts.isIntersectionTypeNode(rtnTypeNode)) {
             intersectionInlinePropsInfo = getIntersectionTypeNodeInfo(rtnTypeNode, vexportToAlias, true, checker);
             if (intersectionInlinePropsInfo.substituteTypeNode) {
@@ -247,6 +250,25 @@ function getPropsInfo(typeRef, vexportToAlias, checker) {
         }
         const rtnType = checker.getTypeAtLocation(rtnTypeNode);
         if (rtnType) {
+            const mappedTypesInfo = getMappedTypesInfo(rtnType, checker, true, rtnTypeNode);
+            if (mappedTypesInfo) {
+                rtnMappedTypes = mappedTypesInfo.mappedTypes;
+                rtnTypeNode = mappedTypesInfo.wrappedTypeNode;
+                if (!isAliasToEGP) {
+                    propsTypeParamsNode = rtnTypeNode;
+                }
+                mappedTypeGenericsDeclaration = TypeUtils.getNodeDeclaration(rtnTypeNode, checker);
+            }
+            else if (isAliasToMappedType(rtnType, rtnTypeNode)) {
+                const scopedTypeAliases = checker.getSymbolsInScope(rtnTypeNode, ts.SymbolFlags.TypeAlias);
+                const aliasMappedTypeName = TypeUtils.getTypeNameFromTypeReference(rtnTypeNode);
+                const aliasToMappedType = scopedTypeAliases.find((sym) => {
+                    return sym.getName() === aliasMappedTypeName;
+                });
+                if (aliasToMappedType) {
+                    mappedTypeGenericsDeclaration = aliasToMappedType.getDeclarations()[0];
+                }
+            }
             let rtnIsInlineTypeLiteral = ts.isTypeLiteralNode(rtnTypeNode);
             let rtnPropsName;
             if (rtnIsInlineIntersectionType) {
@@ -283,12 +305,18 @@ function getPropsInfo(typeRef, vexportToAlias, checker) {
             rtnInfo = {
                 propsType: rtnType,
                 propsName: rtnPropsName,
+                propsMappedTypes: rtnMappedTypes,
                 propsExtendGlobalPropsRef: rtnEGPRef,
             };
             if (!(rtnIsInlineIntersectionType || rtnIsObservedGlobalPropsOnly)) {
-                rtnInfo.propsGenericsDeclaration = !rtnIsInlineTypeLiteral
-                    ? TypeUtils.getTypeDeclaration(rtnType)
-                    : TypeUtils.getNodeDeclaration(propsTypeParamsNode, checker);
+                if (mappedTypeGenericsDeclaration) {
+                    rtnInfo.propsGenericsDeclaration = mappedTypeGenericsDeclaration;
+                }
+                else {
+                    rtnInfo.propsGenericsDeclaration = !rtnIsInlineTypeLiteral
+                        ? TypeUtils.getTypeDeclaration(rtnType)
+                        : TypeUtils.getNodeDeclaration(propsTypeParamsNode, checker);
+                }
                 if (propsTypeParamsNode.typeArguments) {
                     rtnInfo.propsTypeParams = getGenericTypeParameters(propsTypeParamsNode);
                 }
@@ -334,12 +362,138 @@ function getIntersectionTypeNodeInfo(intersectionTypeNode, vexportToAlias, isInl
     return rtnInfo;
 }
 exports.getIntersectionTypeNodeInfo = getIntersectionTypeNodeInfo;
-function walkTypeMembers(type, checker, callback) {
-    const getConstituentTypes = function (type, checker, mappedTypes) {
+const _MAPPED_TYPENAMES = new Set([
+    "Partial",
+    "Required",
+    "Readonly",
+    "Pick",
+    "Omit",
+]);
+function getMappedTypesInfo(outerType, checker, isPropsInfo, outerTypeNode) {
+    var _a;
+    let rtnInfo = null;
+    let mappedTypes = [];
+    let wrappedType = outerType;
+    let wrappedTypeNode = outerTypeNode;
+    while (wrappedType && isPropsInfo
+        ? isPropsMappedType(wrappedType, wrappedTypeNode)
+        : isMappedType(wrappedType)) {
+        const mappedTypeName = TypeUtils.getTypeNameFromType(wrappedType);
+        const mappedTypeArgs = wrappedType.aliasTypeArguments;
+        if (mappedTypeName && mappedTypeArgs) {
+            let params = mappedTypeArgs
+                .slice(1)
+                .map((t) => checker.typeToString(t))
+                .join(", ");
+            const mappedEntry = {
+                name: mappedTypeName,
+            };
+            if (params !== "") {
+                mappedEntry.params = params;
+            }
+            mappedTypes.push(mappedEntry);
+            if (wrappedTypeNode) {
+                wrappedTypeNode = (_a = wrappedTypeNode
+                    .typeArguments) === null || _a === void 0 ? void 0 : _a[0];
+                wrappedType = wrappedTypeNode
+                    ? checker.getTypeAtLocation(wrappedTypeNode)
+                    : null;
+            }
+            else {
+                wrappedType = mappedTypeArgs[0];
+            }
+        }
+        else {
+            break;
+        }
+    }
+    if (mappedTypes.length > 0 && wrappedType) {
+        rtnInfo = {
+            mappedTypes,
+            wrappedTypeName: TypeUtils.getTypeNameFromType(wrappedType),
+        };
+        if (wrappedTypeNode) {
+            rtnInfo.wrappedTypeNode = wrappedTypeNode;
+        }
+    }
+    return rtnInfo;
+}
+exports.getMappedTypesInfo = getMappedTypesInfo;
+function isPropsMappedType(type, typeNode) {
+    return (isMappedType(type) &&
+        _MAPPED_TYPENAMES.has(typeNode
+            ? TypeUtils.getTypeNameFromTypeReference(typeNode)
+            : TypeUtils.getTypeNameFromType(type)));
+}
+exports.isPropsMappedType = isPropsMappedType;
+function isAliasToMappedType(type, typeNode) {
+    return (isMappedType(type) &&
+        !_MAPPED_TYPENAMES.has(TypeUtils.getTypeNameFromTypeReference(typeNode)));
+}
+exports.isAliasToMappedType = isAliasToMappedType;
+function constructMappedTypeName(mappedTypesInfo, wrappedTypeGenerics) {
+    let rtnName = "";
+    let paramsStack = [];
+    let poppedParams;
+    const mappedTypesLast = mappedTypesInfo.mappedTypes.length - 1;
+    mappedTypesInfo.mappedTypes.forEach((mType, i) => {
+        rtnName += mType.name;
+        if (mType.params) {
+            paramsStack.push(mType.params);
+        }
+        else {
+            paramsStack.push(null);
+        }
+        rtnName += "<";
+        if (i === mappedTypesLast) {
+            rtnName += mappedTypesInfo.wrappedTypeName;
+            if (wrappedTypeGenerics) {
+                rtnName += wrappedTypeGenerics;
+            }
+            while (paramsStack.length > 0) {
+                if ((poppedParams = paramsStack.pop())) {
+                    rtnName += `, ${poppedParams}>`;
+                }
+                else {
+                    rtnName += ">";
+                }
+            }
+        }
+    });
+    return rtnName;
+}
+exports.constructMappedTypeName = constructMappedTypeName;
+function isMappedType(type) {
+    var _a;
+    let decl = (_a = type.symbol) === null || _a === void 0 ? void 0 : _a.declarations[0];
+    return decl && ts.isMappedTypeNode(decl);
+}
+exports.isMappedType = isMappedType;
+function walkTypeMembers(type, metaUtilObj, callback) {
+    const isExcludedType = function (type, metaUtilObj) {
+        var _a, _b, _c, _d;
+        let rtnValue = false;
+        const tname = (_a = type.aliasSymbol) === null || _a === void 0 ? void 0 : _a.name;
+        if (tname && ((_b = metaUtilObj.excludedTypes) === null || _b === void 0 ? void 0 : _b.has(tname))) {
+            rtnValue = true;
+        }
+        else {
+            const decl = (_c = type.aliasSymbol) === null || _c === void 0 ? void 0 : _c.declarations[0];
+            if (decl &&
+                ts.isTypeAliasDeclaration(decl) &&
+                ts.isTypeReferenceNode(decl.type) &&
+                ((_d = metaUtilObj.excludedTypeAliases) === null || _d === void 0 ? void 0 : _d.has(TypeUtils.getTypeNameFromTypeReference(decl.type)))) {
+                rtnValue = true;
+            }
+        }
+        return rtnValue;
+    };
+    const getConstituentTypes = function (type, metaUtilObj, typeMap) {
+        const checker = metaUtilObj.typeChecker;
         if (type.isIntersection()) {
             const intersectionTypes = type.types;
             for (let t of intersectionTypes) {
-                getConstituentTypes(t, checker, mappedTypes);
+                getConstituentTypes(t, metaUtilObj, typeMap);
             }
         }
         else {
@@ -351,48 +505,79 @@ function walkTypeMembers(type, checker, callback) {
                         for (let clause of heritageClauses) {
                             for (let typeRef of clause.types) {
                                 const inheritedTypeName = TypeUtils.getTypeNameFromTypeReference(typeRef);
-                                if (!mappedTypes[inheritedTypeName]) {
+                                if (!typeMap[inheritedTypeName]) {
                                     const typeRefType = checker.getTypeAtLocation(typeRef);
                                     if (typeRefType) {
-                                        getConstituentTypes(typeRefType, checker, mappedTypes);
+                                        getConstituentTypes(typeRefType, metaUtilObj, typeMap);
                                     }
                                 }
                             }
                         }
                     }
                 }
-                const typeName = TypeUtils.getTypeNameFromType(type);
-                if (!mappedTypes[typeName]) {
-                    mappedTypes[typeName] = type;
+                if (!isExcludedType(type, metaUtilObj)) {
+                    const typeName = isMappedType(type)
+                        ? checker.typeToString(type)
+                        : TypeUtils.getTypeNameFromType(type);
+                    if (!typeMap[typeName]) {
+                        typeMap[typeName] = type;
+                    }
                 }
             }
         }
     };
-    const processMembers = function (symbol, callback) {
-        const members = symbol === null || symbol === void 0 ? void 0 : symbol.members;
-        if (members) {
-            members.forEach((memberSymbol, memberKey) => {
-                callback(memberSymbol, memberKey);
-            });
+    const processMembers = function (type, checker, callback) {
+        var _a;
+        if (!isMappedType(type)) {
+            const members = (_a = type.getSymbol()) === null || _a === void 0 ? void 0 : _a.members;
+            if (members) {
+                members.forEach((memberSymbol, memberKey) => {
+                    callback(memberSymbol, memberKey);
+                });
+            }
+        }
+        else {
+            const propSymbols = checker.getPropertiesOfType(type);
+            if (propSymbols) {
+                const propCount = propSymbols.length;
+                const rootSymbols = propSymbols.map((sym) => {
+                    var _a;
+                    return (_a = checker.getRootSymbols(sym)) === null || _a === void 0 ? void 0 : _a[0];
+                });
+                for (let symbol, i = 0; i < propCount; i++) {
+                    if (rootSymbols[i]) {
+                        symbol = rootSymbols[i];
+                        callback(symbol, symbol.getEscapedName(), propSymbols[i]);
+                    }
+                    else {
+                        symbol = propSymbols[i];
+                        callback(symbol, symbol.getEscapedName());
+                    }
+                }
+            }
         }
     };
     let typeMap = {};
-    getConstituentTypes(type, checker, typeMap);
-    let typeKeys = Object.keys(typeMap);
+    getConstituentTypes(type, metaUtilObj, typeMap);
+    const typeKeys = Object.keys(typeMap);
+    const checker = metaUtilObj.typeChecker;
     for (let k of typeKeys) {
-        processMembers(typeMap[k].getSymbol(), callback);
+        processMembers(typeMap[k], checker, callback);
     }
 }
 exports.walkTypeMembers = walkTypeMembers;
-function walkTypeNodeMembers(typeNode, checker, callback) {
-    const typeAtLoc = checker.getTypeAtLocation(typeNode);
-    walkTypeMembers(typeAtLoc, checker, callback);
+function walkTypeNodeMembers(typeNode, metaUtilObj, callback) {
+    const typeAtLoc = metaUtilObj.typeChecker.getTypeAtLocation(typeNode);
+    walkTypeMembers(typeAtLoc, metaUtilObj, callback);
 }
 exports.walkTypeNodeMembers = walkTypeNodeMembers;
 function updateCompilerPropsMetadata(propsInfo, readOnlyProps, metaUtilObj) {
     if (propsInfo.propsTypeParams) {
         metaUtilObj.fullMetadata["propsTypeParams"] = propsInfo.propsTypeParams;
     }
+    if (propsInfo.propsMappedTypes.length > 0) {
+        metaUtilObj.fullMetadata["propsMappedTypes"] = propsInfo.propsMappedTypes.slice();
+    }
     let declaration = propsInfo.propsGenericsDeclaration;
     if (declaration &&
         (ts.isClassDeclaration(declaration) ||
@@ -434,6 +619,7 @@ function pruneCompilerMetadata(metaUtilObj) {
     delete metaUtilObj.fullMetadata["classTypeParams"];
     delete metaUtilObj.fullMetadata["classTypeParamsDeclaration"];
     delete metaUtilObj.fullMetadata["propsTypeParams"];
+    delete metaUtilObj.fullMetadata["propsMappedTypes"];
     delete metaUtilObj.fullMetadata["propsClassTypeParamsDeclaration"];
     delete metaUtilObj.fullMetadata["propsClassTypeParams"];
     delete metaUtilObj.fullMetadata["propsTypeParamsAny"];