@xlr-lib/xlr-utils 0.1.1-next.2 → 0.1.1-next.3

package/src/__tests__/validation-helpers.test.ts

@@ -135,7 +135,7 @@ describe("makePropertyMap tests", () => {
 
     const propertyMap = makePropertyMap(treeObject);
 
-    expect(propertyMap.get("'some-key'")?.value).toStrictEqual("value");
-    expect(propertyMap.get("'some-otherkey'")?.value).toStrictEqual("value");
+    expect(propertyMap.get("some-key")?.value).toStrictEqual("value");
+    expect(propertyMap.get("some-otherkey")?.value).toStrictEqual("value");
   });
 });

package/src/ts-helpers.ts

@@ -31,6 +31,15 @@ export function isExportedDeclaration(node: ts.Statement): boolean {
   return false;
 }
 
+/**
+ * Returns if the top level declaration is exported
+ */
+export function isExportedModuleDeclaration(
+  node: ts.Statement,
+): node is ts.ModuleDeclaration {
+  return isExportedDeclaration(node) && ts.isModuleDeclaration(node);
+}
+
 /**
  * Returns if the node is exported from the source file
  */
@@ -49,7 +58,12 @@ export function isNodeExported(node: ts.Node): boolean {
 export function getReferencedType(
   node: ts.TypeReferenceNode,
   typeChecker: ts.TypeChecker,
-) {
+):
+  | {
+      declaration: ts.InterfaceDeclaration | ts.TypeAliasDeclaration;
+      exported: boolean;
+    }
+  | undefined {
   let symbol = typeChecker.getSymbolAtLocation(node.typeName);
 
   if (
@@ -178,12 +192,22 @@ export function buildTemplateRegex(
 export function fillInGenerics(
   xlrNode: NodeType,
   generics?: Map<string, NodeType>,
+  preferLocalGenerics = false,
 ): NodeType {
   // Need to make sure not to set generics in passed in map to avoid using generics outside of tree
   let localGenerics: Map<string, NodeType>;
 
   if (generics) {
     localGenerics = new Map(generics);
+    if (preferLocalGenerics && isGenericNodeType(xlrNode)) {
+      xlrNode.genericTokens?.forEach((token) => {
+        const genericValue = (token.default ?? token.constraints) as NodeType;
+        localGenerics.set(
+          token.symbol,
+          fillInGenerics(genericValue, localGenerics, preferLocalGenerics),
+        );
+      });
+    }
   } else {
     localGenerics = new Map();
     if (isGenericNodeType(xlrNode)) {
@@ -191,7 +215,7 @@ export function fillInGenerics(
         const genericValue = (token.default ?? token.constraints) as NodeType;
         localGenerics.set(
           token.symbol,
-          fillInGenerics(genericValue, localGenerics),
+          fillInGenerics(genericValue, localGenerics, preferLocalGenerics),
         );
       });
     }
@@ -204,7 +228,7 @@ export function fillInGenerics(
         ...(xlrNode.genericArguments
           ? {
               genericArguments: xlrNode.genericArguments.map((ga) =>
-                fillInGenerics(ga, localGenerics),
+                fillInGenerics(ga, localGenerics, preferLocalGenerics),
               ),
             }
           : {}),
@@ -220,7 +244,7 @@ export function fillInGenerics(
       ...(xlrNode.genericArguments
         ? {
             genericArguments: xlrNode.genericArguments.map((ga) =>
-              fillInGenerics(ga, localGenerics),
+              fillInGenerics(ga, localGenerics, preferLocalGenerics),
             ),
           }
         : {}),
@@ -233,7 +257,7 @@ export function fillInGenerics(
       const prop = xlrNode.properties[propName];
       newProperties[propName] = {
         required: prop.required,
-        node: fillInGenerics(prop.node, localGenerics),
+        node: fillInGenerics(prop.node, localGenerics, preferLocalGenerics),
       };
     });
 
@@ -246,20 +270,36 @@ export function fillInGenerics(
               return {
                 ...token,
                 constraints: token.constraints
-                  ? fillInGenerics(token.constraints, localGenerics)
+                  ? fillInGenerics(
+                      token.constraints,
+                      localGenerics,
+                      preferLocalGenerics,
+                    )
                   : undefined,
                 default: token.default
-                  ? fillInGenerics(token.default, localGenerics)
+                  ? fillInGenerics(
+                      token.default,
+                      localGenerics,
+                      preferLocalGenerics,
+                    )
                   : undefined,
               };
             }),
           }
         : {}),
       extends: xlrNode.extends
-        ? (fillInGenerics(xlrNode.extends, localGenerics) as RefNode)
+        ? (fillInGenerics(
+            xlrNode.extends,
+            localGenerics,
+            preferLocalGenerics,
+          ) as RefNode)
         : undefined,
       additionalProperties: xlrNode.additionalProperties
-        ? fillInGenerics(xlrNode.additionalProperties, localGenerics)
+        ? fillInGenerics(
+            xlrNode.additionalProperties,
+            localGenerics,
+            preferLocalGenerics,
+          )
         : false,
     };
   }
@@ -267,7 +307,11 @@ export function fillInGenerics(
   if (xlrNode.type === "array") {
     return {
       ...xlrNode,
-      elementType: fillInGenerics(xlrNode.elementType, localGenerics),
+      elementType: fillInGenerics(
+        xlrNode.elementType,
+        localGenerics,
+        preferLocalGenerics,
+      ),
     };
   } else if (xlrNode.type === "or" || xlrNode.type === "and") {
     let pointer;
@@ -280,25 +324,49 @@ export function fillInGenerics(
     return {
       ...xlrNode,
       [xlrNode.type]: pointer.map((prop) => {
-        return fillInGenerics(prop, localGenerics);
+        return fillInGenerics(prop, localGenerics, preferLocalGenerics);
       }),
     };
   } else if (xlrNode.type === "record") {
     return {
       ...xlrNode,
-      keyType: fillInGenerics(xlrNode.keyType, localGenerics),
-      valueType: fillInGenerics(xlrNode.valueType, localGenerics),
+      keyType: fillInGenerics(
+        xlrNode.keyType,
+        localGenerics,
+        preferLocalGenerics,
+      ),
+      valueType: fillInGenerics(
+        xlrNode.valueType,
+        localGenerics,
+        preferLocalGenerics,
+      ),
     };
   } else if (xlrNode.type === "conditional") {
     const filledInConditional = {
       ...xlrNode,
       check: {
-        left: fillInGenerics(xlrNode.check.left, localGenerics),
-        right: fillInGenerics(xlrNode.check.right, localGenerics),
+        left: fillInGenerics(
+          xlrNode.check.left,
+          localGenerics,
+          preferLocalGenerics,
+        ),
+        right: fillInGenerics(
+          xlrNode.check.right,
+          localGenerics,
+          preferLocalGenerics,
+        ),
       },
       value: {
-        true: fillInGenerics(xlrNode.value.true, localGenerics),
-        false: fillInGenerics(xlrNode.value.false, localGenerics),
+        true: fillInGenerics(
+          xlrNode.value.true,
+          localGenerics,
+          preferLocalGenerics,
+        ),
+        false: fillInGenerics(
+          xlrNode.value.false,
+          localGenerics,
+          preferLocalGenerics,
+        ),
       },
     };
 

package/src/validation-helpers.ts

@@ -20,14 +20,8 @@ export interface PropertyNode {
  * Takes a property node and returns the underlying Key/Value Pairs
  */
 export function propertyToTuple(node: Node): PropertyNode {
-  let key = node.children?.[0].value as string;
-  if (key.includes("-")) {
-    // XLR outputs all escaped properties with single quotes
-    key = `'${key}'`;
-  }
-
   return {
-    key,
+    key: node.children?.[0].value as string,
     value: node.children?.[1] as Node,
   };
 }

package/types/ts-helpers.d.ts

@@ -8,6 +8,10 @@ export declare function tsStripOptionalType(node: ts.TypeNode): ts.TypeNode;
  * Returns if the top level declaration is exported
  */
 export declare function isExportedDeclaration(node: ts.Statement): boolean;
+/**
+ * Returns if the top level declaration is exported
+ */
+export declare function isExportedModuleDeclaration(node: ts.Statement): node is ts.ModuleDeclaration;
 /**
  * Returns if the node is exported from the source file
  */
@@ -16,7 +20,7 @@ export declare function isNodeExported(node: ts.Node): boolean;
  * Returns the actual type and will following import chains if needed
  */
 export declare function getReferencedType(node: ts.TypeReferenceNode, typeChecker: ts.TypeChecker): {
-    declaration: ts.TypeAliasDeclaration | ts.InterfaceDeclaration;
+    declaration: ts.InterfaceDeclaration | ts.TypeAliasDeclaration;
     exported: boolean;
 } | undefined;
 /**
@@ -40,7 +44,7 @@ export declare function buildTemplateRegex(node: ts.TemplateLiteralTypeNode, typ
  * Walks generics to fill in values from a combination of the default, constraint, and passed in map values
  * TODO convert this to use simpleTransformGenerator
  */
-export declare function fillInGenerics(xlrNode: NodeType, generics?: Map<string, NodeType>): NodeType;
+export declare function fillInGenerics(xlrNode: NodeType, generics?: Map<string, NodeType>, preferLocalGenerics?: boolean): NodeType;
 /** Applies the TS `Pick` or `Omit` type to an interface/union/intersection */
 export declare function applyPickOrOmitToNodeType(baseObject: NodeType, operation: "Pick" | "Omit", properties: Set<string>): NodeType | undefined;
 /** Applies the TS `Partial` or `Required` type to an interface/union/intersection */