@player-tools/xlr-converters 0.2.1-next.4 → 0.2.2--canary.17.363

package/dist/index.cjs.js

@@ -103,7 +103,8 @@ class TsConverter {
   }
   convertTsTypeNode(node) {
     if (this.context.cache.convertedNodes.has(node)) {
-      return this.context.cache.convertedNodes.get(node);
+      const cachedType = this.context.cache.convertedNodes.get(node);
+      return JSON.parse(JSON.stringify(cachedType));
     }
     const convertedNode = this.tsNodeToType(node);
     this.context.cache.convertedNodes.set(node, convertedNode);
@@ -265,14 +266,47 @@ class TsConverter {
       if (ts__default["default"].isTypeReferenceNode(node.objectType) && ts__default["default"].isLiteralTypeNode(node.indexType)) {
         const baseObject = this.convertTsTypeNode(node.objectType);
         const accessor = node.indexType.literal.getText().replace(/["']/g, "");
-        if (Object.keys((_d = baseObject.properties) != null ? _d : {}).includes(accessor)) {
-          return baseObject.properties[accessor].node;
+        if (!baseObject) {
+          this.context.throwError(`Error: Couldn't resolve index access on property ${accessor} on type ${node.objectType.typeName.getText()}`);
+        } else if (baseObject.type === "object") {
+          if (Object.keys((_d = baseObject.properties) != null ? _d : {}).includes(accessor)) {
+            return baseObject.properties[accessor].node;
+          }
+          if (baseObject.additionalProperties) {
+            return baseObject.additionalProperties;
+          }
+        } else if (baseObject.type === "ref") {
+          return __spreadProps(__spreadValues$1({}, baseObject), { property: accessor });
+        } else {
+          this.context.throwError(`Error: Index access on non object/ref type ${baseObject.type}`);
         }
-        if (baseObject.additionalProperties) {
-          return baseObject.additionalProperties;
+      }
+      if (ts__default["default"].isTypeQueryNode(node.objectType)) {
+        const effectiveType = this.context.typeChecker.getTypeAtLocation(node);
+        if (ts__default["default"].TypeFlags.Union & effectiveType.flags) {
+          return {
+            type: "or",
+            or: effectiveType.types.map((type) => {
+              if (ts__default["default"].TypeFlags.StringLiteral & type.flags) {
+                return {
+                  type: "string",
+                  const: type.value
+                };
+              }
+              if (ts__default["default"].TypeFlags.NumberLiteral & type.flags) {
+                return {
+                  type: "number",
+                  const: type.value
+                };
+              }
+              return {
+                type: "unknown"
+              };
+            })
+          };
         }
       }
-      return { type: "null" };
+      this.context.throwError(`Error: could not solve IndexedAccessType ${node.getFullText()}`);
     } else {
       this.context.throwError(`Unimplemented type ${ts__default["default"].SyntaxKind[node.kind]}`);
     }
@@ -352,6 +386,9 @@ class TsConverter {
             return;
           }
           typeToApply = this.convertDeclaration(parentInterface);
+          if (typeToApply.extends) {
+            extendsType = typeToApply.extends;
+          }
           if (parentInterface.typeParameters && parent.typeArguments) {
             typeToApply = this.solveGenerics(typeToApply, parentInterface.typeParameters, parent.typeArguments);
           } else if (xlrUtils.isGenericNodeType(baseObject)) {
@@ -540,7 +577,8 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const templateSplit = /(?=true\|false|\.\*|\[0-9]\*)/gm;
+const templateTokenize = /(?=true\|false|\.\*|\[0-9]\*)/gm;
+const tokenSplit = /(?<=true\|false|\.\*|\[0-9]\*)/gm;
 class TSWriter {
   constructor(factory) {
     this.context = {
@@ -571,9 +609,18 @@ class TSWriter {
     if (xlrUtils.isGenericNamedType(type)) {
       generics = this.createTypeParameters(type);
     }
+    let customPrimitiveHeritageClass;
+    if (type.type === "object" && type.extends) {
+      const refName = type.extends.ref.split("<")[0];
+      customPrimitiveHeritageClass = [
+        this.context.factory.createHeritageClause(ts__default["default"].SyntaxKind.ExtendsKeyword, [
+          this.context.factory.createExpressionWithTypeArguments(this.context.factory.createIdentifier(refName), type.extends.genericArguments ? type.extends.genericArguments.map((node) => this.convertTypeNode(node)) : void 0)
+        ])
+      ];
+    }
     let finalNode;
     if (ts__default["default"].isTypeLiteralNode(tsNode)) {
-      finalNode = this.makeInterfaceDeclaration(typeName, tsNode.members, generics);
+      finalNode = this.makeInterfaceDeclaration(typeName, tsNode.members, generics, customPrimitiveHeritageClass);
     } else {
       finalNode = this.makeTypeDeclaration(typeName, tsNode, generics);
     }
@@ -677,7 +724,7 @@ class TSWriter {
       return xlrNode.const ? this.context.factory.createNumericLiteral(xlrNode.const) : this.context.throwError("Can't make literal type out of non constant number");
     }
     if (xlrNode.type === "string") {
-      return xlrNode.const ? this.context.factory.createStringLiteral(xlrNode.const) : this.context.throwError("Can't make literal type out of non constant string");
+      return xlrNode.const ? this.context.factory.createStringLiteral(xlrNode.const, true) : this.context.throwError("Can't make literal type out of non constant string");
     }
     if (xlrNode.type === "null") {
       return this.context.factory.createNull();
@@ -689,7 +736,7 @@ class TSWriter {
   }
   createFunctionDeclarationNode(xlrNode) {
     return this.context.factory.createFunctionTypeNode(void 0, xlrNode.parameters.map((e) => {
-      return this.context.factory.createParameterDeclaration(void 0, void 0, void 0, e.name, e.optional ? this.context.factory.createToken(ts__default["default"].SyntaxKind.QuestionToken) : void 0, this.convertTypeNode(e.type), e.default ? this.createLiteralTypeNode(e.default) : void 0);
+      return this.context.factory.createParameterDeclaration(void 0, void 0, e.name, e.optional ? this.context.factory.createToken(ts__default["default"].SyntaxKind.QuestionToken) : void 0, this.convertTypeNode(e.type), e.default ? this.createLiteralTypeNode(e.default) : void 0);
     }), xlrNode.returnType ? this.convertTypeNode(xlrNode.returnType) : this.context.factory.createToken(ts__default["default"].SyntaxKind.VoidKeyword));
   }
   createRecordNode(xlrNode) {
@@ -710,23 +757,23 @@ class TSWriter {
       ...Object.keys(properties).map((name) => __spreadValues({ name }, properties[name])).map(({ name, node, required }) => this.makeAnnotations(this.context.factory.createPropertySignature(void 0, name, required ? void 0 : this.context.factory.createToken(ts__default["default"].SyntaxKind.QuestionToken), this.convertTypeNode(node)), node))
     ];
     if (additionalProperties) {
-      propertyNodes.push(this.context.factory.createIndexSignature(void 0, void 0, [
-        this.context.factory.createParameterDeclaration(void 0, void 0, void 0, "key", void 0, this.context.factory.createKeywordTypeNode(ts__default["default"].SyntaxKind.StringKeyword))
+      propertyNodes.push(this.context.factory.createIndexSignature(void 0, [
+        this.context.factory.createParameterDeclaration(void 0, void 0, "key", void 0, this.context.factory.createKeywordTypeNode(ts__default["default"].SyntaxKind.StringKeyword))
       ], this.convertTypeNode(additionalProperties)));
     }
     return this.context.factory.createTypeLiteralNode(propertyNodes);
   }
   createTemplateLiteral(xlrNode) {
-    const templateSegments = xlrNode.format.split(templateSplit);
+    const templateSegments = xlrNode.format.split(templateTokenize);
     let templateHead;
-    if (templateSegments.length % 2) {
+    if (templateSegments.length % 2 === 0) {
       templateHead = this.context.factory.createTemplateHead(templateSegments[0]);
       templateSegments.splice(0, 1);
     } else {
       templateHead = this.context.factory.createTemplateHead("");
     }
     return this.context.factory.createTemplateLiteralType(templateHead, templateSegments.map((segments, i) => {
-      const [regexSegment, stringSegment] = segments.split(" ", 1);
+      const [regexSegment, stringSegment = ""] = segments.split(tokenSplit);
       let regexTemplateType;
       if (regexSegment === ".*") {
         regexTemplateType = ts__default["default"].SyntaxKind.StringKeyword;
@@ -776,8 +823,8 @@ ${comment.split("\n").map((s) => ` * ${s}`).join("\n")}
       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(this.context.factory.createModifiersFromModifierFlags(ts__default["default"].ModifierFlags.Export), this.context.factory.createIdentifier(name), generics, void 0, node);
+  makeInterfaceDeclaration(name, node, generics, heritageClass) {
+    return this.context.factory.createInterfaceDeclaration(this.context.factory.createModifiersFromModifierFlags(ts__default["default"].ModifierFlags.Export), this.context.factory.createIdentifier(name), generics, heritageClass, node);
   }
   makeTypeDeclaration(name, node, generics) {
     return this.context.factory.createTypeAliasDeclaration(this.context.factory.createModifiersFromModifierFlags(ts__default["default"].ModifierFlags.Export), this.context.factory.createIdentifier(name), generics, node);

package/dist/index.esm.js

@@ -95,7 +95,8 @@ class TsConverter {
   }
   convertTsTypeNode(node) {
     if (this.context.cache.convertedNodes.has(node)) {
-      return this.context.cache.convertedNodes.get(node);
+      const cachedType = this.context.cache.convertedNodes.get(node);
+      return JSON.parse(JSON.stringify(cachedType));
     }
     const convertedNode = this.tsNodeToType(node);
     this.context.cache.convertedNodes.set(node, convertedNode);
@@ -257,14 +258,47 @@ class TsConverter {
       if (ts.isTypeReferenceNode(node.objectType) && ts.isLiteralTypeNode(node.indexType)) {
         const baseObject = this.convertTsTypeNode(node.objectType);
         const accessor = node.indexType.literal.getText().replace(/["']/g, "");
-        if (Object.keys((_d = baseObject.properties) != null ? _d : {}).includes(accessor)) {
-          return baseObject.properties[accessor].node;
+        if (!baseObject) {
+          this.context.throwError(`Error: Couldn't resolve index access on property ${accessor} on type ${node.objectType.typeName.getText()}`);
+        } else if (baseObject.type === "object") {
+          if (Object.keys((_d = baseObject.properties) != null ? _d : {}).includes(accessor)) {
+            return baseObject.properties[accessor].node;
+          }
+          if (baseObject.additionalProperties) {
+            return baseObject.additionalProperties;
+          }
+        } else if (baseObject.type === "ref") {
+          return __spreadProps(__spreadValues$1({}, baseObject), { property: accessor });
+        } else {
+          this.context.throwError(`Error: Index access on non object/ref type ${baseObject.type}`);
         }
-        if (baseObject.additionalProperties) {
-          return baseObject.additionalProperties;
+      }
+      if (ts.isTypeQueryNode(node.objectType)) {
+        const effectiveType = this.context.typeChecker.getTypeAtLocation(node);
+        if (ts.TypeFlags.Union & effectiveType.flags) {
+          return {
+            type: "or",
+            or: effectiveType.types.map((type) => {
+              if (ts.TypeFlags.StringLiteral & type.flags) {
+                return {
+                  type: "string",
+                  const: type.value
+                };
+              }
+              if (ts.TypeFlags.NumberLiteral & type.flags) {
+                return {
+                  type: "number",
+                  const: type.value
+                };
+              }
+              return {
+                type: "unknown"
+              };
+            })
+          };
         }
       }
-      return { type: "null" };
+      this.context.throwError(`Error: could not solve IndexedAccessType ${node.getFullText()}`);
     } else {
       this.context.throwError(`Unimplemented type ${ts.SyntaxKind[node.kind]}`);
     }
@@ -344,6 +378,9 @@ class TsConverter {
             return;
           }
           typeToApply = this.convertDeclaration(parentInterface);
+          if (typeToApply.extends) {
+            extendsType = typeToApply.extends;
+          }
           if (parentInterface.typeParameters && parent.typeArguments) {
             typeToApply = this.solveGenerics(typeToApply, parentInterface.typeParameters, parent.typeArguments);
           } else if (isGenericNodeType(baseObject)) {
@@ -532,7 +569,8 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const templateSplit = /(?=true\|false|\.\*|\[0-9]\*)/gm;
+const templateTokenize = /(?=true\|false|\.\*|\[0-9]\*)/gm;
+const tokenSplit = /(?<=true\|false|\.\*|\[0-9]\*)/gm;
 class TSWriter {
   constructor(factory) {
     this.context = {
@@ -563,9 +601,18 @@ class TSWriter {
     if (isGenericNamedType(type)) {
       generics = this.createTypeParameters(type);
     }
+    let customPrimitiveHeritageClass;
+    if (type.type === "object" && type.extends) {
+      const refName = type.extends.ref.split("<")[0];
+      customPrimitiveHeritageClass = [
+        this.context.factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [
+          this.context.factory.createExpressionWithTypeArguments(this.context.factory.createIdentifier(refName), type.extends.genericArguments ? type.extends.genericArguments.map((node) => this.convertTypeNode(node)) : void 0)
+        ])
+      ];
+    }
     let finalNode;
     if (ts.isTypeLiteralNode(tsNode)) {
-      finalNode = this.makeInterfaceDeclaration(typeName, tsNode.members, generics);
+      finalNode = this.makeInterfaceDeclaration(typeName, tsNode.members, generics, customPrimitiveHeritageClass);
     } else {
       finalNode = this.makeTypeDeclaration(typeName, tsNode, generics);
     }
@@ -669,7 +716,7 @@ class TSWriter {
       return xlrNode.const ? this.context.factory.createNumericLiteral(xlrNode.const) : this.context.throwError("Can't make literal type out of non constant number");
     }
     if (xlrNode.type === "string") {
-      return xlrNode.const ? this.context.factory.createStringLiteral(xlrNode.const) : this.context.throwError("Can't make literal type out of non constant string");
+      return xlrNode.const ? this.context.factory.createStringLiteral(xlrNode.const, true) : this.context.throwError("Can't make literal type out of non constant string");
     }
     if (xlrNode.type === "null") {
       return this.context.factory.createNull();
@@ -681,7 +728,7 @@ class TSWriter {
   }
   createFunctionDeclarationNode(xlrNode) {
     return this.context.factory.createFunctionTypeNode(void 0, xlrNode.parameters.map((e) => {
-      return this.context.factory.createParameterDeclaration(void 0, void 0, void 0, e.name, e.optional ? this.context.factory.createToken(ts.SyntaxKind.QuestionToken) : void 0, this.convertTypeNode(e.type), e.default ? this.createLiteralTypeNode(e.default) : void 0);
+      return this.context.factory.createParameterDeclaration(void 0, void 0, e.name, e.optional ? this.context.factory.createToken(ts.SyntaxKind.QuestionToken) : void 0, this.convertTypeNode(e.type), e.default ? this.createLiteralTypeNode(e.default) : void 0);
     }), xlrNode.returnType ? this.convertTypeNode(xlrNode.returnType) : this.context.factory.createToken(ts.SyntaxKind.VoidKeyword));
   }
   createRecordNode(xlrNode) {
@@ -702,23 +749,23 @@ class TSWriter {
       ...Object.keys(properties).map((name) => __spreadValues({ name }, properties[name])).map(({ name, node, required }) => this.makeAnnotations(this.context.factory.createPropertySignature(void 0, name, required ? void 0 : this.context.factory.createToken(ts.SyntaxKind.QuestionToken), this.convertTypeNode(node)), node))
     ];
     if (additionalProperties) {
-      propertyNodes.push(this.context.factory.createIndexSignature(void 0, void 0, [
-        this.context.factory.createParameterDeclaration(void 0, void 0, void 0, "key", void 0, this.context.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword))
+      propertyNodes.push(this.context.factory.createIndexSignature(void 0, [
+        this.context.factory.createParameterDeclaration(void 0, void 0, "key", void 0, this.context.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword))
       ], this.convertTypeNode(additionalProperties)));
     }
     return this.context.factory.createTypeLiteralNode(propertyNodes);
   }
   createTemplateLiteral(xlrNode) {
-    const templateSegments = xlrNode.format.split(templateSplit);
+    const templateSegments = xlrNode.format.split(templateTokenize);
     let templateHead;
-    if (templateSegments.length % 2) {
+    if (templateSegments.length % 2 === 0) {
       templateHead = this.context.factory.createTemplateHead(templateSegments[0]);
       templateSegments.splice(0, 1);
     } else {
       templateHead = this.context.factory.createTemplateHead("");
     }
     return this.context.factory.createTemplateLiteralType(templateHead, templateSegments.map((segments, i) => {
-      const [regexSegment, stringSegment] = segments.split(" ", 1);
+      const [regexSegment, stringSegment = ""] = segments.split(tokenSplit);
       let regexTemplateType;
       if (regexSegment === ".*") {
         regexTemplateType = ts.SyntaxKind.StringKeyword;
@@ -768,8 +815,8 @@ ${comment.split("\n").map((s) => ` * ${s}`).join("\n")}
       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(this.context.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), this.context.factory.createIdentifier(name), generics, void 0, node);
+  makeInterfaceDeclaration(name, node, generics, heritageClass) {
+    return this.context.factory.createInterfaceDeclaration(this.context.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), this.context.factory.createIdentifier(name), generics, heritageClass, node);
   }
   makeTypeDeclaration(name, node, generics) {
     return this.context.factory.createTypeAliasDeclaration(this.context.factory.createModifiersFromModifierFlags(ts.ModifierFlags.Export), this.context.factory.createIdentifier(name), generics, node);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@player-tools/xlr-converters",
-  "version": "0.2.1-next.4",
+  "version": "0.2.2--canary.17.363",
   "private": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
@@ -9,8 +9,8 @@
     "typescript": "4.8.4"
   },
   "dependencies": {
-    "@player-tools/xlr": "0.2.1-next.4",
-    "@player-tools/xlr-utils": "0.2.1-next.4",
+    "@player-tools/xlr": "0.2.2--canary.17.363",
+    "@player-tools/xlr-utils": "0.2.2--canary.17.363",
     "@babel/runtime": "7.15.4"
   },
   "main": "dist/index.cjs.js",

package/src/ts-to-xlr.ts

@@ -1,3 +1,8 @@
+import type {
+  NumberLiteralType,
+  StringLiteralType,
+  UnionType,
+} from 'typescript';
 import ts from 'typescript';
 import type {
   NodeType,
@@ -12,6 +17,7 @@ import type {
   ParamTypeNode,
   ConditionalType,
   RefType,
+  OrType,
 } from '@player-tools/xlr';
 import type { TopLevelDeclaration } from '@player-tools/xlr-utils';
 import {
@@ -160,7 +166,11 @@ export class TsConverter {
   /** Converts an arbitrary ts.TypeNode to XLRs */
   public convertTsTypeNode(node: ts.TypeNode): NodeType | undefined {
     if (this.context.cache.convertedNodes.has(node)) {
-      return this.context.cache.convertedNodes.get(node);
+      const cachedType = this.context.cache.convertedNodes.get(
+        node
+      ) as NodeType;
+      // return deep copy of node so modifications don't effect referenced to the original
+      return JSON.parse(JSON.stringify(cachedType));
     }
 
     const convertedNode = this.tsNodeToType(node);
@@ -391,20 +401,63 @@ export class TsConverter {
         ts.isTypeReferenceNode(node.objectType) &&
         ts.isLiteralTypeNode(node.indexType)
       ) {
-        const baseObject = this.convertTsTypeNode(
-          node.objectType
-        ) as ObjectType;
+        const baseObject = this.convertTsTypeNode(node.objectType);
         const accessor = node.indexType.literal.getText().replace(/["']/g, '');
-        if (Object.keys(baseObject.properties ?? {}).includes(accessor)) {
-          return baseObject.properties[accessor].node;
+        if (!baseObject) {
+          this.context.throwError(
+            `Error: Couldn't resolve index access on property ${accessor} on type ${node.objectType.typeName.getText()}`
+          );
+        } else if (baseObject.type === 'object') {
+          if (Object.keys(baseObject.properties ?? {}).includes(accessor)) {
+            return baseObject.properties[accessor].node;
+          }
+
+          if (baseObject.additionalProperties) {
+            return baseObject.additionalProperties;
+          }
+        } else if (baseObject.type === 'ref') {
+          return { ...baseObject, property: accessor };
+        } else {
+          this.context.throwError(
+            `Error: Index access on non object/ref type ${baseObject.type}`
+          );
         }
+      }
 
-        if (baseObject.additionalProperties) {
-          return baseObject.additionalProperties;
+      if (ts.isTypeQueryNode(node.objectType)) {
+        const effectiveType = this.context.typeChecker.getTypeAtLocation(node);
+        // eslint-disable-next-line no-bitwise
+        if (ts.TypeFlags.Union & effectiveType.flags) {
+          return {
+            type: 'or',
+            or: (effectiveType as UnionType).types.map((type) => {
+              // eslint-disable-next-line no-bitwise
+              if (ts.TypeFlags.StringLiteral & type.flags) {
+                return {
+                  type: 'string',
+                  const: (type as StringLiteralType).value,
+                };
+              }
+
+              // eslint-disable-next-line no-bitwise
+              if (ts.TypeFlags.NumberLiteral & type.flags) {
+                return {
+                  type: 'number',
+                  const: (type as NumberLiteralType).value,
+                };
+              }
+
+              return {
+                type: 'unknown',
+              };
+            }),
+          } as OrType;
         }
       }
 
-      return { type: 'null' };
+      this.context.throwError(
+        `Error: could not solve IndexedAccessType ${node.getFullText()}`
+      );
     } else {
       this.context.throwError(`Unimplemented type ${ts.SyntaxKind[node.kind]}`);
     }
@@ -532,6 +585,11 @@ export class TsConverter {
           }
 
           typeToApply = this.convertDeclaration(parentInterface);
+
+          if (typeToApply.extends) {
+            extendsType = typeToApply.extends;
+          }
+
           if (parentInterface.typeParameters && parent.typeArguments) {
             typeToApply = this.solveGenerics(
               typeToApply as NodeTypeWithGenerics,

package/src/xlr-to-ts.ts

@@ -20,7 +20,8 @@ import {
 import ts from 'typescript';
 import { ConversionError } from './types';
 
-const templateSplit = /(?=true\|false|\.\*|\[0-9]\*)/gm;
+const templateTokenize = /(?=true\|false|\.\*|\[0-9]\*)/gm;
+const tokenSplit = /(?<=true\|false|\.\*|\[0-9]\*)/gm;
 
 export interface ConvertedType {
   /** Converted input type represented as in TS Nodes */
@@ -85,12 +86,33 @@ export class TSWriter {
       generics = this.createTypeParameters(type);
     }
 
+    let customPrimitiveHeritageClass;
+    if (type.type === 'object' && type.extends) {
+      const refName = type.extends.ref.split('<')[0];
+      customPrimitiveHeritageClass = [
+        this.context.factory.createHeritageClause(
+          ts.SyntaxKind.ExtendsKeyword,
+          [
+            this.context.factory.createExpressionWithTypeArguments(
+              this.context.factory.createIdentifier(refName),
+              type.extends.genericArguments
+                ? (type.extends.genericArguments.map((node) =>
+                    this.convertTypeNode(node)
+                  ) as any)
+                : undefined
+            ),
+          ]
+        ),
+      ];
+    }
+
     let finalNode;
     if (ts.isTypeLiteralNode(tsNode)) {
       finalNode = this.makeInterfaceDeclaration(
         typeName,
         tsNode.members,
-        generics
+        generics,
+        customPrimitiveHeritageClass
       );
     } else {
       finalNode = this.makeTypeDeclaration(typeName, tsNode, generics);
@@ -263,7 +285,7 @@ export class TSWriter {
 
     if (xlrNode.type === 'string') {
       return xlrNode.const
-        ? this.context.factory.createStringLiteral(xlrNode.const)
+        ? this.context.factory.createStringLiteral(xlrNode.const, true)
         : this.context.throwError(
             "Can't make literal type out of non constant string"
           );
@@ -287,7 +309,6 @@ export class TSWriter {
       undefined,
       xlrNode.parameters.map((e) => {
         return this.context.factory.createParameterDeclaration(
-          undefined,
           undefined,
           undefined,
           e.name,
@@ -351,11 +372,9 @@ export class TSWriter {
     if (additionalProperties) {
       propertyNodes.push(
         this.context.factory.createIndexSignature(
-          undefined, // decorators
           undefined, // modifiers
           [
             this.context.factory.createParameterDeclaration(
-              undefined, // decorators
               undefined, // modifiers
               undefined, // dotdotdot token
               'key',
@@ -374,10 +393,10 @@ export class TSWriter {
   }
 
   private createTemplateLiteral(xlrNode: TemplateLiteralType) {
-    const templateSegments = xlrNode.format.split(templateSplit);
+    const templateSegments = xlrNode.format.split(templateTokenize);
     let templateHead;
 
-    if (templateSegments.length % 2) {
+    if (templateSegments.length % 2 === 0) {
       templateHead = this.context.factory.createTemplateHead(
         templateSegments[0]
       );
@@ -389,7 +408,7 @@ export class TSWriter {
     return this.context.factory.createTemplateLiteralType(
       templateHead,
       templateSegments.map((segments, i) => {
-        const [regexSegment, stringSegment] = segments.split(' ', 1);
+        const [regexSegment, stringSegment = ''] = segments.split(tokenSplit);
 
         let regexTemplateType: ts.KeywordSyntaxKind;
         if (regexSegment === '.*') {
@@ -480,7 +499,8 @@ export class TSWriter {
   private makeInterfaceDeclaration(
     name: string,
     node: ts.NodeArray<ts.TypeElement>,
-    generics: Array<ts.TypeParameterDeclaration> | undefined
+    generics: Array<ts.TypeParameterDeclaration> | undefined,
+    heritageClass: ts.HeritageClause[] | undefined
   ) {
     return this.context.factory.createInterfaceDeclaration(
       this.context.factory.createModifiersFromModifierFlags(
@@ -488,7 +508,7 @@ export class TSWriter {
       ),
       this.context.factory.createIdentifier(name),
       generics, // type parameters
-      undefined, // heritage
+      heritageClass, // heritage
       node
     );
   }