@player-tools/xlr-utils 0.2.1-next.3 → 0.2.1

package/dist/index.cjs.js

@@ -29,19 +29,19 @@ var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
 var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
 var tsvfs__default = /*#__PURE__*/_interopDefaultLegacy(tsvfs);
 
-var __defProp$1 = Object.defineProperty;
-var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
-var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
-var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$1 = (a, b) => {
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$1.call(b, prop))
-      __defNormalProp$1(a, prop, b[prop]);
-  if (__getOwnPropSymbols$1)
-    for (var prop of __getOwnPropSymbols$1(b)) {
-      if (__propIsEnum$1.call(b, prop))
-        __defNormalProp$1(a, prop, b[prop]);
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
     }
   return a;
 };
@@ -132,7 +132,7 @@ function extractTags(tags) {
       descriptions.push(`@${tag.tagName.text} ${text}`);
     }
   });
-  return __spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1({}, descriptions.length === 0 ? {} : { description: descriptions.join("\n") }), examples.length === 0 ? {} : { examples }), _default.length === 0 ? {} : { default: _default.join("\n") }), see.length === 0 ? {} : { see });
+  return __spreadValues$2(__spreadValues$2(__spreadValues$2(__spreadValues$2({}, descriptions.length === 0 ? {} : { description: descriptions.join("\n") }), examples.length === 0 ? {} : { examples }), _default.length === 0 ? {} : { default: _default.join("\n") }), see.length === 0 ? {} : { see });
 }
 function join(t, separator = "\n") {
   const unique = new Set(t).values();
@@ -147,7 +147,7 @@ function mergeAnnotations(nodes) {
   const comment = join(nodes.map((n) => n.comment));
   const examples = join(nodes.map((n) => Array.isArray(n.examples) ? join(n.examples) : n.examples));
   const see = join(nodes.map((n) => Array.isArray(n.see) ? join(n.see) : n.see));
-  return __spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1({}, name ? { name } : {}), title ? { title } : {}), description ? { description } : {}), examples ? { examples } : {}), _default ? { default: _default } : {}), see ? { see } : {}), comment ? { comment } : {});
+  return __spreadValues$2(__spreadValues$2(__spreadValues$2(__spreadValues$2(__spreadValues$2(__spreadValues$2(__spreadValues$2({}, name ? { name } : {}), title ? { title } : {}), description ? { description } : {}), examples ? { examples } : {}), _default ? { default: _default } : {}), see ? { see } : {}), comment ? { comment } : {});
 }
 function decorateNode(node) {
   var _a;
@@ -197,12 +197,31 @@ function isGenericNamedType(nt) {
   return ((_a = nt.genericTokens) == null ? void 0 : _a.length) > 0;
 }
 function isPrimitiveTypeNode(node) {
-  return node.type === "string" || node.type === "number" || node.type === "boolean" || node.type === "null" || node.type === "template" || node.type === "any" || node.type === "never" || node.type === "undefined" || node.type === "unknown";
+  return node.type === "string" || node.type === "number" || node.type === "boolean" || node.type === "null" || node.type === "any" || node.type === "never" || node.type === "undefined" || node.type === "unknown";
 }
 function isNonNullable(a) {
   return a !== null || a !== void 0;
 }
 
+var __defProp$1 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
 function propertyToTuple(node) {
   var _a, _b;
   let key = (_a = node.children) == null ? void 0 : _a[0].value;
@@ -229,22 +248,83 @@ function isNode(obj) {
 function resolveConditional(conditional) {
   const { left, right } = conditional.check;
   if (isPrimitiveTypeNode(left) && isPrimitiveTypeNode(right)) {
-    if (left.const && right.const) {
-      return left.const === right.const ? conditional.value.true : conditional.value.false;
-    }
+    let conditionalResult = conditional.value.false;
     if ((left.type === "any" || left.type === "unknown") && (right.type === "any" || right.type === "unknown")) {
-      return conditional.value.true;
-    }
-    if ((left.type === "null" || left.type === "undefined") && (right.type === "null" || right.type === "undefined")) {
-      return conditional.value.true;
+      conditionalResult = conditional.value.true;
+    } else if ((left.type === "null" || left.type === "undefined") && (right.type === "null" || right.type === "undefined")) {
+      conditionalResult = conditional.value.true;
+    } else if (left.type === right.type) {
+      if (left.const && right.const) {
+        if (left.const === right.const) {
+          conditionalResult = conditional.value.true;
+        }
+      } else {
+        conditionalResult = conditional.value.true;
+      }
     }
-    if (left.type === right.type) {
-      return conditional.value.true;
+    if (isGenericNodeType(conditional)) {
+      const genericMap = new Map();
+      conditional.genericTokens.forEach((token) => {
+        var _a, _b;
+        genericMap.set(token.symbol, (_b = (_a = token.default) != null ? _a : token.constraints) != null ? _b : { type: "any" });
+      });
+      return fillInGenerics(conditionalResult, genericMap);
     }
-    return conditional.value.false;
+    return conditionalResult;
   }
   return conditional;
 }
+function resolveReferenceNode(genericReference, typeToFill) {
+  var _a, _b, _c;
+  const genericArgs = genericReference.genericArguments;
+  const genericMap = new Map();
+  if (genericArgs && isGenericNodeType(typeToFill)) {
+    typeToFill.genericTokens.forEach((token, index) => {
+      var _a2, _b2;
+      genericMap.set(token.symbol, (_b2 = (_a2 = genericArgs[index]) != null ? _a2 : token.default) != null ? _b2 : token.constraints);
+    });
+  }
+  const filledInNode = fillInGenerics(typeToFill, genericMap);
+  if (isGenericNodeType(filledInNode) && (genericArgs == null ? void 0 : genericArgs.length)) {
+    if (genericArgs.length < filledInNode.genericTokens.length) {
+      filledInNode.genericTokens = filledInNode.genericTokens.slice(genericArgs == null ? void 0 : genericArgs.length);
+    } else if (genericArgs.length === filledInNode.genericTokens.length) {
+      filledInNode.genericTokens = [];
+    }
+  }
+  if (genericReference.property && filledInNode.type === "object") {
+    return (_c = (_b = (_a = filledInNode.properties[genericReference.property]) == null ? void 0 : _a.node) != null ? _b : filledInNode.additionalProperties) != null ? _c : { type: "undefined" };
+  }
+  return filledInNode;
+}
+function computeEffectiveObject(base, operand, errorOnOverlap = true) {
+  var _a, _b;
+  const baseObjectName = (_a = base.name) != null ? _a : "object literal";
+  const operandObjectName = (_b = operand.name) != null ? _b : "object literal";
+  const newObject = __spreadProps$1(__spreadValues$1({}, base), {
+    name: `${baseObjectName} & ${operandObjectName}`,
+    description: `Effective type combining ${baseObjectName} and ${operandObjectName}`,
+    genericTokens: [
+      ...isGenericNodeType(base) ? base.genericTokens : [],
+      ...isGenericNodeType(operand) ? operand.genericTokens : []
+    ]
+  });
+  for (const property in operand.properties) {
+    if (newObject.properties[property] !== void 0 && newObject.properties[property].node.type !== operand.properties[property].node.type && errorOnOverlap) {
+      throw new Error(`Can't compute effective type for ${baseObjectName} and ${operandObjectName} because of conflicting properties ${property}`);
+    }
+    newObject.properties[property] = operand.properties[property];
+  }
+  if (newObject.additionalProperties && operand.additionalProperties) {
+    newObject.additionalProperties = {
+      type: "and",
+      and: [newObject.additionalProperties, operand.additionalProperties]
+    };
+  } else if (operand.additionalProperties) {
+    newObject.additionalProperties = operand.additionalProperties;
+  }
+  return newObject;
+}
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
@@ -269,8 +349,8 @@ function tsStripOptionalType(node) {
   return ts__namespace.isOptionalTypeNode(node) ? node.type : node;
 }
 function isExportedDeclaration(node) {
-  var _a;
-  return !!((_a = node.modifiers) == null ? void 0 : _a.some((modifier) => modifier.kind === ts__namespace.SyntaxKind.ExportKeyword));
+  const modifiers = ts__namespace.canHaveModifiers(node) ? ts__namespace.getModifiers(node) : void 0;
+  return modifiers && modifiers.some((modifier) => modifier.kind === ts__namespace.SyntaxKind.ExportKeyword);
 }
 function isNodeExported(node) {
   return (ts__namespace.getCombinedModifierFlags(node) & ts__namespace.ModifierFlags.Export) !== 0 || !!node.parent && node.parent.kind === ts__namespace.SyntaxKind.SourceFile;
@@ -458,47 +538,26 @@ function applyPartialOrRequiredToNodeType(baseObject, modifier) {
   throw new Error(`Error: Can not apply ${modifier ? "Required" : "Partial"} to type ${baseObject.type}`);
 }
 
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 function setupTestEnv(sourceCode, mockFileName = "filename.ts") {
-  return __async(this, null, function* () {
-    const fsMap = yield tsvfs__default["default"].createDefaultMapFromNodeModules({}, ts__default["default"]);
-    fsMap.set(mockFileName, sourceCode);
-    const system = tsvfs__default["default"].createSystem(fsMap);
-    const host = tsvfs__default["default"].createVirtualCompilerHost(system, {}, ts__default["default"]);
-    const program = ts__default["default"].createProgram({
-      rootNames: [...fsMap.keys()],
-      options: {},
-      host: host.compilerHost
-    });
-    return {
-      sf: host.compilerHost.getSourceFile(mockFileName, ts__default["default"].ScriptTarget.ES5),
-      tc: program.getTypeChecker()
-    };
+  const fsMap = tsvfs__default["default"].createDefaultMapFromNodeModules({}, ts__default["default"]);
+  fsMap.set(mockFileName, sourceCode);
+  const system = tsvfs__default["default"].createSystem(fsMap);
+  const host = tsvfs__default["default"].createVirtualCompilerHost(system, {}, ts__default["default"]);
+  const program = ts__default["default"].createProgram({
+    rootNames: [...fsMap.keys()],
+    options: {},
+    host: host.compilerHost
   });
+  return {
+    sf: host.compilerHost.getSourceFile(mockFileName, ts__default["default"].ScriptTarget.ES5),
+    tc: program.getTypeChecker()
+  };
 }
 
 exports.applyPartialOrRequiredToNodeType = applyPartialOrRequiredToNodeType;
 exports.applyPickOrOmitToNodeType = applyPickOrOmitToNodeType;
 exports.buildTemplateRegex = buildTemplateRegex;
+exports.computeEffectiveObject = computeEffectiveObject;
 exports.decorateNode = decorateNode;
 exports.fillInGenerics = fillInGenerics;
 exports.getReferencedType = getReferencedType;
@@ -518,6 +577,7 @@ exports.isTypeReferenceGeneric = isTypeReferenceGeneric;
 exports.makePropertyMap = makePropertyMap;
 exports.propertyToTuple = propertyToTuple;
 exports.resolveConditional = resolveConditional;
+exports.resolveReferenceNode = resolveReferenceNode;
 exports.setupTestEnv = setupTestEnv;
 exports.tsStripOptionalType = tsStripOptionalType;
 //# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as ts from 'typescript';
 import ts__default from 'typescript';
-import { Annotations, NodeType, NodeTypeWithGenerics, NamedType, NamedTypeWithGenerics, PrimitiveTypes, ConditionalType } from '@player-tools/xlr';
+import { Annotations, NodeType, NodeTypeWithGenerics, NamedType, NamedTypeWithGenerics, PrimitiveTypes, ConditionalType, RefNode, ObjectType } from '@player-tools/xlr';
 import { Node } from 'jsonc-parser';
 
 /**
@@ -15,7 +15,7 @@ declare function tsStripOptionalType(node: ts.TypeNode): ts.TypeNode;
 /**
  * Returns if the top level declaration is exported
  */
-declare function isExportedDeclaration(node: ts.Statement): boolean;
+declare function isExportedDeclaration(node: ts.Statement): boolean | undefined;
 /**
  * Returns if the node is exported from the source file
  */
@@ -37,6 +37,7 @@ declare function getStringLiteralsFromUnion(node: ts.Node): Set<string>;
 declare function buildTemplateRegex(node: ts.TemplateLiteralTypeNode, typeChecker: ts.TypeChecker): string;
 /**
  * Walks generics to fill in values from a combination of the default, constraint, and passed in map values
+ * TODO convert this to use simpleTransformGenerator
  */
 declare function fillInGenerics(xlrNode: NodeType, generics?: Map<string, NodeType>): NodeType;
 /** Applies the TS `Pick` type to an interface/union/intersection */
@@ -104,6 +105,18 @@ declare function isNode(obj: Node | string | number | boolean): obj is Node;
  * Attempts to resolve a conditional type
  */
 declare function resolveConditional(conditional: ConditionalType): NodeType;
+/**
+ *
+ */
+declare function resolveReferenceNode(genericReference: RefNode, typeToFill: NodeType): NodeType;
+/**
+ * Combines two ObjectType objects to get a representation of the effective TypeScript interface of `base` extending `operand`
+ - * @param base The base interface
+ - * @param operand The interface that is extended
+ - * @param errorOnOverlap whether or not conflicting properties should throw an error or use the property from operand
+ - * @returns `ObjectType`
+ */
+declare function computeEffectiveObject(base: ObjectType, operand: ObjectType, errorOnOverlap?: boolean): ObjectType;
 
 interface SetupReturnType {
     /**
@@ -118,9 +131,9 @@ interface SetupReturnType {
 /**
  * Setups a virtual TS environment for tests
  */
-declare function setupTestEnv(sourceCode: string, mockFileName?: string): Promise<{
+declare function setupTestEnv(sourceCode: string, mockFileName?: string): {
     sf: ts__default.SourceFile;
     tc: ts__default.TypeChecker;
-}>;
+};
 
-export { PropertyNode, SetupReturnType, TopLevelDeclaration, applyPartialOrRequiredToNodeType, applyPickOrOmitToNodeType, buildTemplateRegex, decorateNode, fillInGenerics, getReferencedType, getStringLiteralsFromUnion, isExportedDeclaration, isGenericInterfaceDeclaration, isGenericNamedType, isGenericNodeType, isGenericTypeDeclaration, isNode, isNodeExported, isNonNullable, isOptionalProperty, isPrimitiveTypeNode, isTopLevelNode, isTypeReferenceGeneric, makePropertyMap, propertyToTuple, resolveConditional, setupTestEnv, tsStripOptionalType };
+export { PropertyNode, SetupReturnType, TopLevelDeclaration, applyPartialOrRequiredToNodeType, applyPickOrOmitToNodeType, buildTemplateRegex, computeEffectiveObject, decorateNode, fillInGenerics, getReferencedType, getStringLiteralsFromUnion, isExportedDeclaration, isGenericInterfaceDeclaration, isGenericNamedType, isGenericNodeType, isGenericTypeDeclaration, isNode, isNodeExported, isNonNullable, isOptionalProperty, isPrimitiveTypeNode, isTopLevelNode, isTypeReferenceGeneric, makePropertyMap, propertyToTuple, resolveConditional, resolveReferenceNode, setupTestEnv, tsStripOptionalType };

package/dist/index.esm.js

@@ -2,19 +2,19 @@ import * as ts from 'typescript';
 import ts__default from 'typescript';
 import tsvfs from '@typescript/vfs';
 
-var __defProp$1 = Object.defineProperty;
-var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
-var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
-var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$1 = (a, b) => {
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$1.call(b, prop))
-      __defNormalProp$1(a, prop, b[prop]);
-  if (__getOwnPropSymbols$1)
-    for (var prop of __getOwnPropSymbols$1(b)) {
-      if (__propIsEnum$1.call(b, prop))
-        __defNormalProp$1(a, prop, b[prop]);
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
     }
   return a;
 };
@@ -105,7 +105,7 @@ function extractTags(tags) {
       descriptions.push(`@${tag.tagName.text} ${text}`);
     }
   });
-  return __spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1({}, descriptions.length === 0 ? {} : { description: descriptions.join("\n") }), examples.length === 0 ? {} : { examples }), _default.length === 0 ? {} : { default: _default.join("\n") }), see.length === 0 ? {} : { see });
+  return __spreadValues$2(__spreadValues$2(__spreadValues$2(__spreadValues$2({}, descriptions.length === 0 ? {} : { description: descriptions.join("\n") }), examples.length === 0 ? {} : { examples }), _default.length === 0 ? {} : { default: _default.join("\n") }), see.length === 0 ? {} : { see });
 }
 function join(t, separator = "\n") {
   const unique = new Set(t).values();
@@ -120,7 +120,7 @@ function mergeAnnotations(nodes) {
   const comment = join(nodes.map((n) => n.comment));
   const examples = join(nodes.map((n) => Array.isArray(n.examples) ? join(n.examples) : n.examples));
   const see = join(nodes.map((n) => Array.isArray(n.see) ? join(n.see) : n.see));
-  return __spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1(__spreadValues$1({}, name ? { name } : {}), title ? { title } : {}), description ? { description } : {}), examples ? { examples } : {}), _default ? { default: _default } : {}), see ? { see } : {}), comment ? { comment } : {});
+  return __spreadValues$2(__spreadValues$2(__spreadValues$2(__spreadValues$2(__spreadValues$2(__spreadValues$2(__spreadValues$2({}, name ? { name } : {}), title ? { title } : {}), description ? { description } : {}), examples ? { examples } : {}), _default ? { default: _default } : {}), see ? { see } : {}), comment ? { comment } : {});
 }
 function decorateNode(node) {
   var _a;
@@ -170,12 +170,31 @@ function isGenericNamedType(nt) {
   return ((_a = nt.genericTokens) == null ? void 0 : _a.length) > 0;
 }
 function isPrimitiveTypeNode(node) {
-  return node.type === "string" || node.type === "number" || node.type === "boolean" || node.type === "null" || node.type === "template" || node.type === "any" || node.type === "never" || node.type === "undefined" || node.type === "unknown";
+  return node.type === "string" || node.type === "number" || node.type === "boolean" || node.type === "null" || node.type === "any" || node.type === "never" || node.type === "undefined" || node.type === "unknown";
 }
 function isNonNullable(a) {
   return a !== null || a !== void 0;
 }
 
+var __defProp$1 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
 function propertyToTuple(node) {
   var _a, _b;
   let key = (_a = node.children) == null ? void 0 : _a[0].value;
@@ -202,22 +221,83 @@ function isNode(obj) {
 function resolveConditional(conditional) {
   const { left, right } = conditional.check;
   if (isPrimitiveTypeNode(left) && isPrimitiveTypeNode(right)) {
-    if (left.const && right.const) {
-      return left.const === right.const ? conditional.value.true : conditional.value.false;
-    }
+    let conditionalResult = conditional.value.false;
     if ((left.type === "any" || left.type === "unknown") && (right.type === "any" || right.type === "unknown")) {
-      return conditional.value.true;
-    }
-    if ((left.type === "null" || left.type === "undefined") && (right.type === "null" || right.type === "undefined")) {
-      return conditional.value.true;
+      conditionalResult = conditional.value.true;
+    } else if ((left.type === "null" || left.type === "undefined") && (right.type === "null" || right.type === "undefined")) {
+      conditionalResult = conditional.value.true;
+    } else if (left.type === right.type) {
+      if (left.const && right.const) {
+        if (left.const === right.const) {
+          conditionalResult = conditional.value.true;
+        }
+      } else {
+        conditionalResult = conditional.value.true;
+      }
     }
-    if (left.type === right.type) {
-      return conditional.value.true;
+    if (isGenericNodeType(conditional)) {
+      const genericMap = new Map();
+      conditional.genericTokens.forEach((token) => {
+        var _a, _b;
+        genericMap.set(token.symbol, (_b = (_a = token.default) != null ? _a : token.constraints) != null ? _b : { type: "any" });
+      });
+      return fillInGenerics(conditionalResult, genericMap);
     }
-    return conditional.value.false;
+    return conditionalResult;
   }
   return conditional;
 }
+function resolveReferenceNode(genericReference, typeToFill) {
+  var _a, _b, _c;
+  const genericArgs = genericReference.genericArguments;
+  const genericMap = new Map();
+  if (genericArgs && isGenericNodeType(typeToFill)) {
+    typeToFill.genericTokens.forEach((token, index) => {
+      var _a2, _b2;
+      genericMap.set(token.symbol, (_b2 = (_a2 = genericArgs[index]) != null ? _a2 : token.default) != null ? _b2 : token.constraints);
+    });
+  }
+  const filledInNode = fillInGenerics(typeToFill, genericMap);
+  if (isGenericNodeType(filledInNode) && (genericArgs == null ? void 0 : genericArgs.length)) {
+    if (genericArgs.length < filledInNode.genericTokens.length) {
+      filledInNode.genericTokens = filledInNode.genericTokens.slice(genericArgs == null ? void 0 : genericArgs.length);
+    } else if (genericArgs.length === filledInNode.genericTokens.length) {
+      filledInNode.genericTokens = [];
+    }
+  }
+  if (genericReference.property && filledInNode.type === "object") {
+    return (_c = (_b = (_a = filledInNode.properties[genericReference.property]) == null ? void 0 : _a.node) != null ? _b : filledInNode.additionalProperties) != null ? _c : { type: "undefined" };
+  }
+  return filledInNode;
+}
+function computeEffectiveObject(base, operand, errorOnOverlap = true) {
+  var _a, _b;
+  const baseObjectName = (_a = base.name) != null ? _a : "object literal";
+  const operandObjectName = (_b = operand.name) != null ? _b : "object literal";
+  const newObject = __spreadProps$1(__spreadValues$1({}, base), {
+    name: `${baseObjectName} & ${operandObjectName}`,
+    description: `Effective type combining ${baseObjectName} and ${operandObjectName}`,
+    genericTokens: [
+      ...isGenericNodeType(base) ? base.genericTokens : [],
+      ...isGenericNodeType(operand) ? operand.genericTokens : []
+    ]
+  });
+  for (const property in operand.properties) {
+    if (newObject.properties[property] !== void 0 && newObject.properties[property].node.type !== operand.properties[property].node.type && errorOnOverlap) {
+      throw new Error(`Can't compute effective type for ${baseObjectName} and ${operandObjectName} because of conflicting properties ${property}`);
+    }
+    newObject.properties[property] = operand.properties[property];
+  }
+  if (newObject.additionalProperties && operand.additionalProperties) {
+    newObject.additionalProperties = {
+      type: "and",
+      and: [newObject.additionalProperties, operand.additionalProperties]
+    };
+  } else if (operand.additionalProperties) {
+    newObject.additionalProperties = operand.additionalProperties;
+  }
+  return newObject;
+}
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
@@ -242,8 +322,8 @@ function tsStripOptionalType(node) {
   return ts.isOptionalTypeNode(node) ? node.type : node;
 }
 function isExportedDeclaration(node) {
-  var _a;
-  return !!((_a = node.modifiers) == null ? void 0 : _a.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword));
+  const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+  return modifiers && modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
 }
 function isNodeExported(node) {
   return (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export) !== 0 || !!node.parent && node.parent.kind === ts.SyntaxKind.SourceFile;
@@ -431,43 +511,21 @@ function applyPartialOrRequiredToNodeType(baseObject, modifier) {
   throw new Error(`Error: Can not apply ${modifier ? "Required" : "Partial"} to type ${baseObject.type}`);
 }
 
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 function setupTestEnv(sourceCode, mockFileName = "filename.ts") {
-  return __async(this, null, function* () {
-    const fsMap = yield tsvfs.createDefaultMapFromNodeModules({}, ts__default);
-    fsMap.set(mockFileName, sourceCode);
-    const system = tsvfs.createSystem(fsMap);
-    const host = tsvfs.createVirtualCompilerHost(system, {}, ts__default);
-    const program = ts__default.createProgram({
-      rootNames: [...fsMap.keys()],
-      options: {},
-      host: host.compilerHost
-    });
-    return {
-      sf: host.compilerHost.getSourceFile(mockFileName, ts__default.ScriptTarget.ES5),
-      tc: program.getTypeChecker()
-    };
+  const fsMap = tsvfs.createDefaultMapFromNodeModules({}, ts__default);
+  fsMap.set(mockFileName, sourceCode);
+  const system = tsvfs.createSystem(fsMap);
+  const host = tsvfs.createVirtualCompilerHost(system, {}, ts__default);
+  const program = ts__default.createProgram({
+    rootNames: [...fsMap.keys()],
+    options: {},
+    host: host.compilerHost
   });
+  return {
+    sf: host.compilerHost.getSourceFile(mockFileName, ts__default.ScriptTarget.ES5),
+    tc: program.getTypeChecker()
+  };
 }
 
-export { applyPartialOrRequiredToNodeType, applyPickOrOmitToNodeType, buildTemplateRegex, decorateNode, fillInGenerics, getReferencedType, getStringLiteralsFromUnion, isExportedDeclaration, isGenericInterfaceDeclaration, isGenericNamedType, isGenericNodeType, isGenericTypeDeclaration, isNode, isNodeExported, isNonNullable, isOptionalProperty, isPrimitiveTypeNode, isTopLevelNode, isTypeReferenceGeneric, makePropertyMap, propertyToTuple, resolveConditional, setupTestEnv, tsStripOptionalType };
+export { applyPartialOrRequiredToNodeType, applyPickOrOmitToNodeType, buildTemplateRegex, computeEffectiveObject, decorateNode, fillInGenerics, getReferencedType, getStringLiteralsFromUnion, isExportedDeclaration, isGenericInterfaceDeclaration, isGenericNamedType, isGenericNodeType, isGenericTypeDeclaration, isNode, isNodeExported, isNonNullable, isOptionalProperty, isPrimitiveTypeNode, isTopLevelNode, isTypeReferenceGeneric, makePropertyMap, propertyToTuple, resolveConditional, resolveReferenceNode, setupTestEnv, tsStripOptionalType };
 //# sourceMappingURL=index.esm.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@player-tools/xlr-utils",
-  "version": "0.2.1-next.3",
+  "version": "0.2.1",
   "private": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
@@ -10,7 +10,7 @@
     "jsonc-parser": "^2.3.1"
   },
   "dependencies": {
-    "@player-tools/xlr": "0.2.1-next.3",
+    "@player-tools/xlr": "0.2.1",
     "@typescript/vfs": "^1.4.0",
     "@babel/runtime": "7.15.4"
   },

package/src/test-helpers.ts

@@ -15,11 +15,8 @@ export interface SetupReturnType {
 /**
  * Setups a virtual TS environment for tests
  */
-export async function setupTestEnv(
-  sourceCode: string,
-  mockFileName = 'filename.ts'
-) {
-  const fsMap = await tsvfs.createDefaultMapFromNodeModules({}, ts);
+export function setupTestEnv(sourceCode: string, mockFileName = 'filename.ts') {
+  const fsMap = tsvfs.createDefaultMapFromNodeModules({}, ts);
   fsMap.set(mockFileName, sourceCode);
 
   const system = tsvfs.createSystem(fsMap);

package/src/ts-helpers.ts

@@ -20,8 +20,12 @@ export function tsStripOptionalType(node: ts.TypeNode): ts.TypeNode {
  * Returns if the top level declaration is exported
  */
 export function isExportedDeclaration(node: ts.Statement) {
-  return !!node.modifiers?.some(
-    (modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword
+  const modifiers = ts.canHaveModifiers(node)
+    ? ts.getModifiers(node)
+    : undefined;
+  return (
+    modifiers &&
+    modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)
   );
 }
 
@@ -129,6 +133,7 @@ export function buildTemplateRegex(
 
 /**
  * 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 function fillInGenerics(
   xlrNode: NodeType,

package/src/type-checks.ts

@@ -90,7 +90,6 @@ export function isPrimitiveTypeNode(node: NodeType): node is PrimitiveTypes {
     node.type === 'number' ||
     node.type === 'boolean' ||
     node.type === 'null' ||
-    node.type === 'template' ||
     node.type === 'any' ||
     node.type === 'never' ||
     node.type === 'undefined' ||

package/src/validation-helpers.ts

@@ -1,6 +1,12 @@
 import type { Node } from 'jsonc-parser';
-import type { ConditionalType, NodeType } from '@player-tools/xlr';
-import { isPrimitiveTypeNode } from './type-checks';
+import type {
+  ConditionalType,
+  NodeType,
+  ObjectType,
+  RefNode,
+} from '@player-tools/xlr';
+import { isGenericNodeType, isPrimitiveTypeNode } from './type-checks';
+import { fillInGenerics } from './ts-helpers';
 
 export interface PropertyNode {
   /** Equivalent Property Name */
@@ -54,35 +60,143 @@ export function isNode(obj: Node | string | number | boolean): obj is Node {
 export function resolveConditional(conditional: ConditionalType): NodeType {
   const { left, right } = conditional.check;
   if (isPrimitiveTypeNode(left) && isPrimitiveTypeNode(right)) {
-    if (left.const && right.const) {
-      return left.const === right.const
-        ? conditional.value.true
-        : conditional.value.false;
-    }
+    let conditionalResult = conditional.value.false;
 
-    // special case for any/unknown being functionally the same
     if (
       (left.type === 'any' || left.type === 'unknown') &&
       (right.type === 'any' || right.type === 'unknown')
     ) {
-      return conditional.value.true;
-    }
-
-    // special case for null/undefined being functionally the same
-    if (
+      // special case for any/unknown being functionally the same
+      conditionalResult = conditional.value.true;
+    } else if (
       (left.type === 'null' || left.type === 'undefined') &&
       (right.type === 'null' || right.type === 'undefined')
     ) {
-      return conditional.value.true;
+      // special case for null/undefined being functionally the same
+      conditionalResult = conditional.value.true;
+    } else if (left.type === right.type) {
+      if (left.const && right.const) {
+        if (left.const === right.const) {
+          conditionalResult = conditional.value.true;
+        }
+      } else {
+        conditionalResult = conditional.value.true;
+      }
     }
 
-    if (left.type === right.type) {
-      return conditional.value.true;
+    // Compose first level generics here since `conditionalResult` won't have them
+    if (isGenericNodeType(conditional)) {
+      const genericMap: Map<string, NodeType> = new Map();
+      conditional.genericTokens.forEach((token) => {
+        genericMap.set(
+          token.symbol,
+          token.default ?? token.constraints ?? { type: 'any' }
+        );
+      });
+
+      return fillInGenerics(conditionalResult, genericMap);
     }
 
-    return conditional.value.false;
+    return conditionalResult;
   }
 
   // unable to process return original
   return conditional;
 }
+
+/**
+ *
+ */
+export function resolveReferenceNode(
+  genericReference: RefNode,
+  typeToFill: NodeType
+): NodeType {
+  const genericArgs = genericReference.genericArguments;
+  const genericMap: Map<string, NodeType> = new Map();
+
+  // Compose first level generics here from `genericReference`
+  if (genericArgs && isGenericNodeType(typeToFill)) {
+    typeToFill.genericTokens.forEach((token, index) => {
+      genericMap.set(
+        token.symbol,
+        genericArgs[index] ?? token.default ?? token.constraints
+      );
+    });
+  }
+
+  // Fill in generics
+  const filledInNode = fillInGenerics(typeToFill, genericMap);
+
+  // Remove generic tokens that were resolve
+  if (isGenericNodeType(filledInNode) && genericArgs?.length) {
+    if (genericArgs.length < filledInNode.genericTokens.length) {
+      filledInNode.genericTokens = filledInNode.genericTokens.slice(
+        genericArgs?.length
+      );
+    } else if (genericArgs.length === filledInNode.genericTokens.length) {
+      filledInNode.genericTokens = [];
+    }
+  }
+
+  // Resolve index access
+  if (genericReference.property && filledInNode.type === 'object') {
+    return (
+      filledInNode.properties[genericReference.property]?.node ??
+      filledInNode.additionalProperties ?? { type: 'undefined' }
+    );
+  }
+
+  return filledInNode;
+}
+
+/**
+ * Combines two ObjectType objects to get a representation of the effective TypeScript interface of `base` extending `operand`
+ - * @param base The base interface
+ - * @param operand The interface that is extended
+ - * @param errorOnOverlap whether or not conflicting properties should throw an error or use the property from operand
+ - * @returns `ObjectType`
+ */
+export function computeEffectiveObject(
+  base: ObjectType,
+  operand: ObjectType,
+  errorOnOverlap = true
+): ObjectType {
+  const baseObjectName = base.name ?? 'object literal';
+  const operandObjectName = operand.name ?? 'object literal';
+  const newObject = {
+    ...base,
+    name: `${baseObjectName} & ${operandObjectName}`,
+    description: `Effective type combining ${baseObjectName} and ${operandObjectName}`,
+    genericTokens: [
+      ...(isGenericNodeType(base) ? base.genericTokens : []),
+      ...(isGenericNodeType(operand) ? operand.genericTokens : []),
+    ],
+  };
+
+  // eslint-disable-next-line no-restricted-syntax, guard-for-in
+  for (const property in operand.properties) {
+    if (
+      newObject.properties[property] !== undefined &&
+      newObject.properties[property].node.type !==
+        operand.properties[property].node.type &&
+      errorOnOverlap
+    ) {
+      throw new Error(
+        `Can't compute effective type for ${baseObjectName} and ${operandObjectName} because of conflicting properties ${property}`
+      );
+    }
+
+    newObject.properties[property] = operand.properties[property];
+  }
+
+  if (newObject.additionalProperties && operand.additionalProperties) {
+    newObject.additionalProperties = {
+      type: 'and',
+      and: [newObject.additionalProperties, operand.additionalProperties],
+    };
+  } else if (operand.additionalProperties) {
+    newObject.additionalProperties = operand.additionalProperties;
+  }
+
+  return newObject;
+}