@player-tools/xlr-converters 0.2.1-next.0 → 0.2.1-next.2

package/dist/index.cjs.js

@@ -38,6 +38,9 @@ var __spreadValues$1 = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+function isMappedTypeNode(x) {
+  return ["Pick", "Omit", "Required", "Partial"].includes(x);
+}
 const AnyTypeNode = {
   type: "any"
 };
@@ -327,34 +330,37 @@ class TsConverter {
     clauses.forEach((heritageClause) => {
       heritageClause.types.forEach((parent) => {
         var _a;
-        const parentType = typeChecker.getTypeAtLocation(parent);
-        const parentSymbol = parentType.symbol;
-        const parentDeclarations = parentSymbol == null ? void 0 : parentSymbol.declarations;
-        let parentInterface = parentDeclarations == null ? void 0 : parentDeclarations[0];
-        if (parentInterface && ts__default["default"].isTypeLiteralNode(parentInterface) && ts__default["default"].isTypeAliasDeclaration(parentInterface.parent)) {
-          parentInterface = parentInterface.parent;
-        }
-        if (parentInterface && xlrUtils.isTopLevelNode(parentInterface)) {
+        let typeToApply;
+        const typeName = parent.expression.getText();
+        if (isMappedTypeNode(typeName)) {
+          typeToApply = this.makeMappedType(typeName, parent);
+        } else {
+          const parentType = typeChecker.getTypeAtLocation(parent);
+          const parentSymbol = parentType.symbol;
+          const parentDeclarations = parentSymbol == null ? void 0 : parentSymbol.declarations;
+          if (!(parentDeclarations == null ? void 0 : parentDeclarations[0])) {
+            this.context.throwError(`Error: Unable to get underlying interface for extending class ${parent.getFullText()}`);
+          }
+          let parentInterface;
+          if (ts__default["default"].isTypeLiteralNode(parentDeclarations == null ? void 0 : parentDeclarations[0]) && ts__default["default"].isTypeAliasDeclaration(parentDeclarations == null ? void 0 : parentDeclarations[0].parent)) {
+            parentInterface = parentDeclarations == null ? void 0 : parentDeclarations[0].parent;
+          } else {
+            parentInterface = parentDeclarations == null ? void 0 : parentDeclarations[0];
+          }
           if (this.context.customPrimitives.includes(parentInterface.name.text)) {
             extendsType = this.makeBasicRefNode(parent);
-          } else {
-            const parentInterfaceType = this.convertDeclaration(parentInterface);
-            if (parentInterface.typeParameters && parent.typeArguments) {
-              const filledInInterface = this.solveGenerics(parentInterfaceType, parentInterface.typeParameters, parent.typeArguments);
-              newProperties = __spreadValues$1(__spreadValues$1({}, newProperties), filledInInterface.properties);
-              if (filledInInterface.additionalProperties) {
-                additionalPropertiesCollector.push(filledInInterface.additionalProperties);
-              }
-            } else {
-              if (xlrUtils.isGenericNodeType(baseObject)) {
-                baseObject.genericTokens.push(...(_a = parentInterfaceType.genericTokens) != null ? _a : []);
-              }
-              newProperties = __spreadValues$1(__spreadValues$1({}, newProperties), parentInterfaceType.properties);
-              if (parentInterfaceType.additionalProperties) {
-                additionalPropertiesCollector.push(parentInterfaceType.additionalProperties);
-              }
-            }
+            return;
           }
+          typeToApply = this.convertDeclaration(parentInterface);
+          if (parentInterface.typeParameters && parent.typeArguments) {
+            typeToApply = this.solveGenerics(typeToApply, parentInterface.typeParameters, parent.typeArguments);
+          } else if (xlrUtils.isGenericNodeType(baseObject)) {
+            baseObject.genericTokens.push(...(_a = typeToApply.genericTokens) != null ? _a : []);
+          }
+        }
+        newProperties = __spreadValues$1(__spreadValues$1({}, newProperties), typeToApply.properties);
+        if (typeToApply.additionalProperties) {
+          additionalPropertiesCollector.push(typeToApply.additionalProperties);
         }
       });
     });
@@ -415,7 +421,7 @@ class TsConverter {
     return genericArray;
   }
   resolveRefNode(node) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    var _a, _b, _c, _d, _e;
     let refName;
     if (node.typeName.kind === ts__default["default"].SyntaxKind.QualifiedName) {
       refName = `${node.typeName.left.getText()}.${node.typeName.right.getText()}`;
@@ -455,20 +461,8 @@ class TsConverter {
         valueType: (_e = this.convertTsTypeNode(valueType)) != null ? _e : AnyTypeNode
       }, xlrUtils.decorateNode(node));
     }
-    if (refName === "Pick" || refName === "Omit") {
-      const baseType = (_f = node.typeArguments) == null ? void 0 : _f[0];
-      const modifiers = (_g = node.typeArguments) == null ? void 0 : _g[1];
-      const baseObj = this.convertTsTypeNode(baseType);
-      const modifierNames = xlrUtils.getStringLiteralsFromUnion(modifiers);
-      return (_h = xlrUtils.applyPickOrOmitToNodeType(baseObj, refName, modifierNames)) != null ? _h : {
-        type: "never"
-      };
-    }
-    if (refName === "Partial" || refName === "Required") {
-      const baseType = (_i = node.typeArguments) == null ? void 0 : _i[0];
-      const baseObj = this.convertTsTypeNode(baseType);
-      const modifier = refName !== "Partial";
-      return xlrUtils.applyPartialOrRequiredToNodeType(baseObj, modifier);
+    if (isMappedTypeNode(refName)) {
+      return this.makeMappedType(refName, node);
     }
     if (!this.context.customPrimitives.includes(refName)) {
       const typeInfo = xlrUtils.getReferencedType(node, this.context.typeChecker);
@@ -487,6 +481,23 @@ class TsConverter {
     }
     return this.makeBasicRefNode(node);
   }
+  makeMappedType(refName, node) {
+    var _a, _b, _c;
+    if (refName === "Pick" || refName === "Omit") {
+      const baseType = (_a = node.typeArguments) == null ? void 0 : _a[0];
+      const modifiers = (_b = node.typeArguments) == null ? void 0 : _b[1];
+      const baseObj = this.convertTsTypeNode(baseType);
+      const modifierNames = xlrUtils.getStringLiteralsFromUnion(modifiers);
+      return xlrUtils.applyPickOrOmitToNodeType(baseObj, refName, modifierNames);
+    }
+    if (refName === "Partial" || refName === "Required") {
+      const baseType = (_c = node.typeArguments) == null ? void 0 : _c[0];
+      const baseObj = this.convertTsTypeNode(baseType);
+      const modifier = refName !== "Partial";
+      return xlrUtils.applyPartialOrRequiredToNodeType(baseObj, modifier);
+    }
+    this.context.throwError(`Can't convert non-MappedType ${refName}`);
+  }
   makeBasicRefNode(node) {
     const genericArgs = [];
     if (node.typeArguments) {
@@ -760,16 +771,16 @@ ${comment.split("\n").map((s) => ` * ${s}`).join("\n")}
     }
     return ts__default["default"].addSyntheticLeadingComment(tsNode, ts__default["default"].SyntaxKind.MultiLineCommentTrivia, comment, true);
   }
-  createTypeParameters(genericxlrNode) {
-    return genericxlrNode.genericTokens.map((generic) => {
-      return this.context.factory.createTypeParameterDeclaration(generic.symbol, this.createGenericArgumentNode(generic.constraints), this.createGenericArgumentNode(generic.default));
+  createTypeParameters(genericXLRNode) {
+    return genericXLRNode.genericTokens.map((generic) => {
+      return this.context.factory.createTypeParameterDeclaration(void 0, generic.symbol, this.createGenericArgumentNode(generic.constraints), this.createGenericArgumentNode(generic.default));
     });
   }
   makeInterfaceDeclaration(name, node, generics) {
-    return this.context.factory.createInterfaceDeclaration(void 0, this.context.factory.createModifiersFromModifierFlags(ts__default["default"].ModifierFlags.Export), this.context.factory.createIdentifier(name), generics, void 0, node);
+    return this.context.factory.createInterfaceDeclaration(this.context.factory.createModifiersFromModifierFlags(ts__default["default"].ModifierFlags.Export), this.context.factory.createIdentifier(name), generics, void 0, node);
   }
   makeTypeDeclaration(name, node, generics) {
-    return this.context.factory.createTypeAliasDeclaration(void 0, this.context.factory.createModifiersFromModifierFlags(ts__default["default"].ModifierFlags.Export), this.context.factory.createIdentifier(name), generics, node);
+    return this.context.factory.createTypeAliasDeclaration(this.context.factory.createModifiersFromModifierFlags(ts__default["default"].ModifierFlags.Export), this.context.factory.createIdentifier(name), generics, node);
   }
 }
 

package/dist/index.d.ts

@@ -25,7 +25,7 @@ declare class TsConverter {
     convertSourceFile(sourceFile: ts.SourceFile): {
         data: {
             version: number;
-            types: NamedType<NodeType>[];
+            types: NonNullable<NamedType<NodeType>>[];
         };
         convertedTypes: string[];
     };
@@ -40,6 +40,7 @@ declare class TsConverter {
     private solveGenerics;
     private generateGenerics;
     private resolveRefNode;
+    private makeMappedType;
     private makeBasicRefNode;
 }
 

package/dist/index.esm.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { isExportedDeclaration, isGenericTypeDeclaration, decorateNode, isGenericInterfaceDeclaration, isNonNullable, buildTemplateRegex, resolveConditional, isOptionalProperty, tsStripOptionalType, isTopLevelNode, isGenericNodeType, fillInGenerics, isTypeReferenceGeneric, getStringLiteralsFromUnion, applyPickOrOmitToNodeType, applyPartialOrRequiredToNodeType, getReferencedType, isGenericNamedType, isPrimitiveTypeNode } from '@player-tools/xlr-utils';
+import { isExportedDeclaration, isGenericTypeDeclaration, decorateNode, isGenericInterfaceDeclaration, isNonNullable, buildTemplateRegex, resolveConditional, isOptionalProperty, tsStripOptionalType, isGenericNodeType, fillInGenerics, isTypeReferenceGeneric, getReferencedType, getStringLiteralsFromUnion, applyPickOrOmitToNodeType, applyPartialOrRequiredToNodeType, isTopLevelNode, isGenericNamedType, isPrimitiveTypeNode } from '@player-tools/xlr-utils';
 
 class ConversionError extends Error {
   constructor(msg) {
@@ -30,6 +30,9 @@ var __spreadValues$1 = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+function isMappedTypeNode(x) {
+  return ["Pick", "Omit", "Required", "Partial"].includes(x);
+}
 const AnyTypeNode = {
   type: "any"
 };
@@ -319,34 +322,37 @@ class TsConverter {
     clauses.forEach((heritageClause) => {
       heritageClause.types.forEach((parent) => {
         var _a;
-        const parentType = typeChecker.getTypeAtLocation(parent);
-        const parentSymbol = parentType.symbol;
-        const parentDeclarations = parentSymbol == null ? void 0 : parentSymbol.declarations;
-        let parentInterface = parentDeclarations == null ? void 0 : parentDeclarations[0];
-        if (parentInterface && ts.isTypeLiteralNode(parentInterface) && ts.isTypeAliasDeclaration(parentInterface.parent)) {
-          parentInterface = parentInterface.parent;
-        }
-        if (parentInterface && isTopLevelNode(parentInterface)) {
+        let typeToApply;
+        const typeName = parent.expression.getText();
+        if (isMappedTypeNode(typeName)) {
+          typeToApply = this.makeMappedType(typeName, parent);
+        } else {
+          const parentType = typeChecker.getTypeAtLocation(parent);
+          const parentSymbol = parentType.symbol;
+          const parentDeclarations = parentSymbol == null ? void 0 : parentSymbol.declarations;
+          if (!(parentDeclarations == null ? void 0 : parentDeclarations[0])) {
+            this.context.throwError(`Error: Unable to get underlying interface for extending class ${parent.getFullText()}`);
+          }
+          let parentInterface;
+          if (ts.isTypeLiteralNode(parentDeclarations == null ? void 0 : parentDeclarations[0]) && ts.isTypeAliasDeclaration(parentDeclarations == null ? void 0 : parentDeclarations[0].parent)) {
+            parentInterface = parentDeclarations == null ? void 0 : parentDeclarations[0].parent;
+          } else {
+            parentInterface = parentDeclarations == null ? void 0 : parentDeclarations[0];
+          }
           if (this.context.customPrimitives.includes(parentInterface.name.text)) {
             extendsType = this.makeBasicRefNode(parent);
-          } else {
-            const parentInterfaceType = this.convertDeclaration(parentInterface);
-            if (parentInterface.typeParameters && parent.typeArguments) {
-              const filledInInterface = this.solveGenerics(parentInterfaceType, parentInterface.typeParameters, parent.typeArguments);
-              newProperties = __spreadValues$1(__spreadValues$1({}, newProperties), filledInInterface.properties);
-              if (filledInInterface.additionalProperties) {
-                additionalPropertiesCollector.push(filledInInterface.additionalProperties);
-              }
-            } else {
-              if (isGenericNodeType(baseObject)) {
-                baseObject.genericTokens.push(...(_a = parentInterfaceType.genericTokens) != null ? _a : []);
-              }
-              newProperties = __spreadValues$1(__spreadValues$1({}, newProperties), parentInterfaceType.properties);
-              if (parentInterfaceType.additionalProperties) {
-                additionalPropertiesCollector.push(parentInterfaceType.additionalProperties);
-              }
-            }
+            return;
           }
+          typeToApply = this.convertDeclaration(parentInterface);
+          if (parentInterface.typeParameters && parent.typeArguments) {
+            typeToApply = this.solveGenerics(typeToApply, parentInterface.typeParameters, parent.typeArguments);
+          } else if (isGenericNodeType(baseObject)) {
+            baseObject.genericTokens.push(...(_a = typeToApply.genericTokens) != null ? _a : []);
+          }
+        }
+        newProperties = __spreadValues$1(__spreadValues$1({}, newProperties), typeToApply.properties);
+        if (typeToApply.additionalProperties) {
+          additionalPropertiesCollector.push(typeToApply.additionalProperties);
         }
       });
     });
@@ -407,7 +413,7 @@ class TsConverter {
     return genericArray;
   }
   resolveRefNode(node) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    var _a, _b, _c, _d, _e;
     let refName;
     if (node.typeName.kind === ts.SyntaxKind.QualifiedName) {
       refName = `${node.typeName.left.getText()}.${node.typeName.right.getText()}`;
@@ -447,20 +453,8 @@ class TsConverter {
         valueType: (_e = this.convertTsTypeNode(valueType)) != null ? _e : AnyTypeNode
       }, decorateNode(node));
     }
-    if (refName === "Pick" || refName === "Omit") {
-      const baseType = (_f = node.typeArguments) == null ? void 0 : _f[0];
-      const modifiers = (_g = node.typeArguments) == null ? void 0 : _g[1];
-      const baseObj = this.convertTsTypeNode(baseType);
-      const modifierNames = getStringLiteralsFromUnion(modifiers);
-      return (_h = applyPickOrOmitToNodeType(baseObj, refName, modifierNames)) != null ? _h : {
-        type: "never"
-      };
-    }
-    if (refName === "Partial" || refName === "Required") {
-      const baseType = (_i = node.typeArguments) == null ? void 0 : _i[0];
-      const baseObj = this.convertTsTypeNode(baseType);
-      const modifier = refName !== "Partial";
-      return applyPartialOrRequiredToNodeType(baseObj, modifier);
+    if (isMappedTypeNode(refName)) {
+      return this.makeMappedType(refName, node);
     }
     if (!this.context.customPrimitives.includes(refName)) {
       const typeInfo = getReferencedType(node, this.context.typeChecker);
@@ -479,6 +473,23 @@ class TsConverter {
     }
     return this.makeBasicRefNode(node);
   }
+  makeMappedType(refName, node) {
+    var _a, _b, _c;
+    if (refName === "Pick" || refName === "Omit") {
+      const baseType = (_a = node.typeArguments) == null ? void 0 : _a[0];
+      const modifiers = (_b = node.typeArguments) == null ? void 0 : _b[1];
+      const baseObj = this.convertTsTypeNode(baseType);
+      const modifierNames = getStringLiteralsFromUnion(modifiers);
+      return applyPickOrOmitToNodeType(baseObj, refName, modifierNames);
+    }
+    if (refName === "Partial" || refName === "Required") {
+      const baseType = (_c = node.typeArguments) == null ? void 0 : _c[0];
+      const baseObj = this.convertTsTypeNode(baseType);
+      const modifier = refName !== "Partial";
+      return applyPartialOrRequiredToNodeType(baseObj, modifier);
+    }
+    this.context.throwError(`Can't convert non-MappedType ${refName}`);
+  }
   makeBasicRefNode(node) {
     const genericArgs = [];
     if (node.typeArguments) {
@@ -752,16 +763,16 @@ ${comment.split("\n").map((s) => ` * ${s}`).join("\n")}
     }
     return ts.addSyntheticLeadingComment(tsNode, ts.SyntaxKind.MultiLineCommentTrivia, comment, true);
   }
-  createTypeParameters(genericxlrNode) {
-    return genericxlrNode.genericTokens.map((generic) => {
-      return this.context.factory.createTypeParameterDeclaration(generic.symbol, this.createGenericArgumentNode(generic.constraints), this.createGenericArgumentNode(generic.default));
+  createTypeParameters(genericXLRNode) {
+    return genericXLRNode.genericTokens.map((generic) => {
+      return this.context.factory.createTypeParameterDeclaration(void 0, generic.symbol, this.createGenericArgumentNode(generic.constraints), this.createGenericArgumentNode(generic.default));
     });
   }
   makeInterfaceDeclaration(name, node, generics) {
-    return this.context.factory.createInterfaceDeclaration(void 0, this.context.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), this.context.factory.createIdentifier(name), generics, void 0, node);
+    return this.context.factory.createInterfaceDeclaration(this.context.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), this.context.factory.createIdentifier(name), generics, void 0, node);
   }
   makeTypeDeclaration(name, node, generics) {
-    return this.context.factory.createTypeAliasDeclaration(void 0, this.context.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), this.context.factory.createIdentifier(name), generics, node);
+    return this.context.factory.createTypeAliasDeclaration(this.context.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), this.context.factory.createIdentifier(name), generics, node);
   }
 }
 

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@player-tools/xlr-converters",
-  "version": "0.2.1-next.0",
+  "version": "0.2.1-next.2",
   "private": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
   },
   "peerDependencies": {
-    "typescript": "4.4.4"
+    "typescript": "4.8.4"
   },
   "dependencies": {
-    "@player-tools/xlr": "0.2.1-next.0",
-    "@player-tools/xlr-utils": "0.2.1-next.0",
+    "@player-tools/xlr": "0.2.1-next.2",
+    "@player-tools/xlr-utils": "0.2.1-next.2",
     "@babel/runtime": "7.15.4"
   },
   "main": "dist/index.cjs.js",

package/src/ts-to-xlr.ts

@@ -35,6 +35,15 @@ import {
 } from '@player-tools/xlr-utils';
 import { ConversionError } from './types';
 
+/**
+ * Returns if the string is one of TypeScript's MappedTypes
+ */
+export function isMappedTypeNode(
+  x: string
+): x is 'Pick' | 'Omit' | 'Required' | 'Partial' {
+  return ['Pick', 'Omit', 'Required', 'Partial'].includes(x);
+}
+
 export interface TSConverterContext {
   /** */
   customPrimitives: Array<string>;
@@ -486,66 +495,66 @@ export class TsConverter {
 
     clauses.forEach((heritageClause) => {
       heritageClause.types.forEach((parent) => {
-        const parentType = typeChecker.getTypeAtLocation(parent);
-        const parentSymbol = parentType.symbol;
-        const parentDeclarations = parentSymbol?.declarations;
-        let parentInterface = parentDeclarations?.[0];
-
-        if (
-          parentInterface &&
-          ts.isTypeLiteralNode(parentInterface) &&
-          ts.isTypeAliasDeclaration(parentInterface.parent)
-        ) {
-          // check for if the node is a type to get the actual type declaration
-          parentInterface = parentInterface.parent;
-        }
+        let typeToApply: ObjectType;
+
+        // Check if its a Mapped Type
+        const typeName = parent.expression.getText();
+        if (isMappedTypeNode(typeName)) {
+          typeToApply = this.makeMappedType(typeName, parent) as ObjectType;
+        } else {
+          const parentType = typeChecker.getTypeAtLocation(parent);
+          const parentSymbol = parentType.symbol;
+          const parentDeclarations = parentSymbol?.declarations;
+
+          if (!parentDeclarations?.[0]) {
+            this.context.throwError(
+              `Error: Unable to get underlying interface for extending class ${parent.getFullText()}`
+            );
+          }
+
+          let parentInterface: TopLevelDeclaration;
+
+          if (
+            ts.isTypeLiteralNode(parentDeclarations?.[0]) &&
+            ts.isTypeAliasDeclaration(parentDeclarations?.[0].parent)
+          ) {
+            // check for if the node is a type to get the actual type declaration
+            parentInterface = parentDeclarations?.[0].parent;
+          } else {
+            parentInterface = parentDeclarations?.[0] as TopLevelDeclaration;
+          }
 
-        if (parentInterface && isTopLevelNode(parentInterface)) {
           if (
             this.context.customPrimitives.includes(parentInterface.name.text)
           ) {
             extendsType = this.makeBasicRefNode(parent);
-          } else {
-            const parentInterfaceType =
-              this.convertDeclaration(parentInterface);
-            if (parentInterface.typeParameters && parent.typeArguments) {
-              const filledInInterface = this.solveGenerics(
-                parentInterfaceType as NodeTypeWithGenerics,
-                parentInterface.typeParameters,
-                parent.typeArguments
-              ) as NamedType<ObjectType>;
-              newProperties = {
-                ...newProperties,
-                ...filledInInterface.properties,
-              };
-              if (filledInInterface.additionalProperties) {
-                additionalPropertiesCollector.push(
-                  filledInInterface.additionalProperties
-                );
-              }
-            } else {
-              if (isGenericNodeType(baseObject)) {
-                baseObject.genericTokens.push(
-                  ...((parentInterfaceType as NodeTypeWithGenerics)
-                    .genericTokens ?? [])
-                );
-              }
-
-              newProperties = {
-                ...newProperties,
-                ...parentInterfaceType.properties,
-              };
-              if (parentInterfaceType.additionalProperties) {
-                additionalPropertiesCollector.push(
-                  parentInterfaceType.additionalProperties
-                );
-              }
-            }
+            return;
           }
+
+          typeToApply = this.convertDeclaration(parentInterface);
+          if (parentInterface.typeParameters && parent.typeArguments) {
+            typeToApply = this.solveGenerics(
+              typeToApply as NodeTypeWithGenerics,
+              parentInterface.typeParameters,
+              parent.typeArguments
+            ) as NamedType<ObjectType>;
+          } else if (isGenericNodeType(baseObject)) {
+            baseObject.genericTokens.push(
+              ...((typeToApply as NodeTypeWithGenerics).genericTokens ?? [])
+            );
+          }
+        }
+
+        newProperties = {
+          ...newProperties,
+          ...typeToApply.properties,
+        };
+        if (typeToApply.additionalProperties) {
+          additionalPropertiesCollector.push(typeToApply.additionalProperties);
         }
       });
     });
-
+    // Resolve Additional Properties
     let additionalProperties: NodeType | false = false;
     if (baseObject.additionalProperties === false) {
       if (additionalPropertiesCollector.length === 1) {
@@ -682,26 +691,8 @@ export class TsConverter {
       };
     }
 
-    if (refName === 'Pick' || refName === 'Omit') {
-      const baseType = node.typeArguments?.[0] as ts.TypeNode;
-      const modifiers = node.typeArguments?.[1] as ts.TypeNode;
-
-      const baseObj = this.convertTsTypeNode(baseType) as NamedType<ObjectType>;
-      const modifierNames = getStringLiteralsFromUnion(modifiers);
-
-      return (
-        applyPickOrOmitToNodeType(baseObj, refName, modifierNames) ?? {
-          type: 'never',
-        }
-      );
-    }
-
-    if (refName === 'Partial' || refName === 'Required') {
-      const baseType = node.typeArguments?.[0] as ts.TypeNode;
-      const baseObj = this.convertTsTypeNode(baseType) as NodeType;
-      const modifier = refName !== 'Partial';
-
-      return applyPartialOrRequiredToNodeType(baseObj, modifier);
+    if (isMappedTypeNode(refName)) {
+      return this.makeMappedType(refName, node);
     }
 
     // catch all for all other type references
@@ -732,6 +723,35 @@ export class TsConverter {
     return this.makeBasicRefNode(node);
   }
 
+  private makeMappedType(
+    refName: 'Pick' | 'Omit' | 'Partial' | 'Required',
+    node: ts.NodeWithTypeArguments
+  ): ObjectType {
+    if (refName === 'Pick' || refName === 'Omit') {
+      const baseType = node.typeArguments?.[0] as ts.TypeNode;
+      const modifiers = node.typeArguments?.[1] as ts.TypeNode;
+
+      const baseObj = this.convertTsTypeNode(baseType) as NamedType<ObjectType>;
+      const modifierNames = getStringLiteralsFromUnion(modifiers);
+
+      return applyPickOrOmitToNodeType(
+        baseObj,
+        refName,
+        modifierNames
+      ) as ObjectType;
+    }
+
+    if (refName === 'Partial' || refName === 'Required') {
+      const baseType = node.typeArguments?.[0] as ts.TypeNode;
+      const baseObj = this.convertTsTypeNode(baseType) as NodeType;
+      const modifier = refName !== 'Partial';
+
+      return applyPartialOrRequiredToNodeType(baseObj, modifier) as ObjectType;
+    }
+
+    this.context.throwError(`Can't convert non-MappedType ${refName}`);
+  }
+
   private makeBasicRefNode(node: ts.NodeWithTypeArguments): RefType {
     const genericArgs: Array<NodeType | NamedType<ObjectType>> = [];
     if (node.typeArguments) {

package/src/xlr-to-ts.ts

@@ -465,10 +465,11 @@ export class TSWriter {
   }
 
   private createTypeParameters(
-    genericxlrNode: NodeTypeWithGenerics
+    genericXLRNode: NodeTypeWithGenerics
   ): Array<ts.TypeParameterDeclaration> {
-    return genericxlrNode.genericTokens.map((generic) => {
+    return genericXLRNode.genericTokens.map((generic) => {
       return this.context.factory.createTypeParameterDeclaration(
+        undefined,
         generic.symbol,
         this.createGenericArgumentNode(generic.constraints),
         this.createGenericArgumentNode(generic.default)
@@ -482,7 +483,6 @@ export class TSWriter {
     generics: Array<ts.TypeParameterDeclaration> | undefined
   ) {
     return this.context.factory.createInterfaceDeclaration(
-      undefined,
       this.context.factory.createModifiersFromModifierFlags(
         ts.ModifierFlags.Export
       ),
@@ -499,7 +499,6 @@ export class TSWriter {
     generics: Array<ts.TypeParameterDeclaration> | undefined
   ) {
     return this.context.factory.createTypeAliasDeclaration(
-      undefined, // decorators
       this.context.factory.createModifiersFromModifierFlags(
         ts.ModifierFlags.Export
       ),