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

package/dist/index.cjs.js

@@ -10,41 +10,23 @@ var ts = require('typescript');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
 var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
 var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
 
-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$3 = Object.defineProperty;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (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$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
     }
   return a;
 };
@@ -56,7 +38,7 @@ class BasicXLRRegistry {
   }
   get(id) {
     const value = this.typeMap.get(id);
-    return value ? __spreadValues$1({}, value) : void 0;
+    return value ? __spreadValues$3({}, value) : void 0;
   }
   add(type, plugin, capability) {
     this.typeMap.set(type.name, type);
@@ -96,28 +78,28 @@ class BasicXLRRegistry {
   }
 }
 
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
+var __defProp$2 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+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.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(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;
 };
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
 class XLRValidator {
-  constructor(typeMap) {
-    this.typeMap = typeMap;
+  constructor(resolveType) {
+    this.resolveType = resolveType;
     this.regexCache = new Map();
   }
   validateType(rootNode, xlrNode) {
@@ -158,7 +140,7 @@ class XLRValidator {
         message: `Does not match any of the expected types for type: '${xlrNode.name}'`
       });
     } else if (xlrNode.type === "and") {
-      const effectiveType = this.computeIntersectionType(xlrNode.and);
+      const effectiveType = __spreadValues$2(__spreadValues$2({}, this.computeIntersectionType(xlrNode.and)), xlrNode.name ? { name: xlrNode.name } : {});
       validationIssues.push(...this.validateType(rootNode, effectiveType));
     } else if (xlrNode.type === "record") {
       (_a = rootNode.children) == null ? void 0 : _a.forEach((child) => {
@@ -194,11 +176,24 @@ class XLRValidator {
         }
       }
     } else if (xlrNode.type === "conditional") {
-      const resolvedType = xlrUtils.resolveConditional(xlrNode);
-      if (resolvedType === xlrNode) {
+      let { right, left } = xlrNode.check;
+      if (right.type === "ref") {
+        right = this.getRefType(right);
+      }
+      if (left.type === "ref") {
+        left = this.getRefType(left);
+      }
+      const resolvedXLRNode = __spreadProps$2(__spreadValues$2({}, xlrNode), {
+        check: {
+          left,
+          right
+        }
+      });
+      const resolvedConditional = xlrUtils.resolveConditional(resolvedXLRNode);
+      if (resolvedConditional === resolvedXLRNode) {
         throw Error(`Unable to resolve conditional type at runtime: ${xlrNode.name}`);
       }
-      validationIssues.push(...this.validateType(rootNode, resolvedType));
+      validationIssues.push(...this.validateType(rootNode, resolvedConditional));
     } else {
       throw Error(`Unknown type ${xlrNode.type}`);
     }
@@ -234,7 +229,7 @@ class XLRValidator {
     let effectiveXLRNode = xlrNode;
     if (xlrNode.extends) {
       const extendedNode = this.getRefType(xlrNode.extends);
-      effectiveXLRNode = this.computeEffectiveObject(extendedNode, xlrNode);
+      effectiveXLRNode = xlrUtils.computeEffectiveObject(extendedNode, xlrNode);
     }
     for (const prop in effectiveXLRNode.properties) {
       const expectedType = effectiveXLRNode.properties[prop];
@@ -295,19 +290,14 @@ class XLRValidator {
   }
   getRefType(ref) {
     let refName = ref.ref;
-    const { genericArguments } = ref;
     if (refName.indexOf("<") > 0) {
       [refName] = refName.split("<");
     }
-    const actualType = this.typeMap.get(refName);
-    const genericMap = new Map();
-    if (genericArguments && xlrUtils.isGenericNodeType(actualType)) {
-      actualType.genericTokens.forEach((token, index) => {
-        var _a, _b;
-        genericMap.set(token.symbol, (_b = (_a = genericArguments[index]) != null ? _a : token.default) != null ? _b : token.constraints);
-      });
+    const actualType = this.resolveType(refName);
+    if (!actualType) {
+      throw new Error(`Error: can't resolve type reference ${refName}`);
     }
-    return xlrUtils.fillInGenerics(actualType, genericMap);
+    return xlrUtils.resolveReferenceNode(ref, actualType);
   }
   getRegex(expString) {
     if (this.regexCache.has(expString)) {
@@ -325,6 +315,12 @@ class XLRValidator {
     }
     if (firstElement.type === "and") {
       effectiveType = this.computeIntersectionType(firstElement.and);
+    } else if (firstElement.type === "record") {
+      effectiveType = {
+        type: "object",
+        properties: {},
+        additionalProperties: firstElement.valueType
+      };
     } else if (firstElement.type !== "or" && firstElement.type !== "object") {
       throw new Error(`Can't compute a union with a non-object type ${firstElement.type} (${firstElement.name})`);
     } else {
@@ -332,6 +328,13 @@ class XLRValidator {
     }
     types.slice(1).forEach((type) => {
       let typeToApply = type;
+      if (typeToApply.type === "record") {
+        typeToApply = {
+          type: "object",
+          properties: {},
+          additionalProperties: typeToApply.valueType
+        };
+      }
       if (type.type === "ref") {
         typeToApply = this.getRefType(type);
       }
@@ -340,15 +343,15 @@ class XLRValidator {
       }
       if (typeToApply.type === "object") {
         if (effectiveType.type === "object") {
-          effectiveType = this.computeEffectiveObject(effectiveType, typeToApply);
+          effectiveType = xlrUtils.computeEffectiveObject(effectiveType, typeToApply);
         } else {
-          effectiveType = __spreadProps(__spreadValues({}, effectiveType), {
+          effectiveType = __spreadProps$2(__spreadValues$2({}, effectiveType), {
             or: effectiveType.or.map((y) => this.computeIntersectionType([y, typeToApply]))
           });
         }
       } else if (typeToApply.type === "or") {
         if (effectiveType.type === "object") {
-          effectiveType = __spreadProps(__spreadValues({}, typeToApply), {
+          effectiveType = __spreadProps$2(__spreadValues$2({}, typeToApply), {
             or: typeToApply.or.map((y) => this.computeIntersectionType([y, effectiveType]))
           });
         } else {
@@ -360,32 +363,130 @@ class XLRValidator {
     });
     return effectiveType;
   }
-  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(__spreadValues({}, base), {
-      name: `${baseObjectName} & ${operandObjectName}`,
-      description: `Effective type combining ${baseObjectName} and ${operandObjectName}`
-    });
-    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];
+}
+
+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]);
     }
-    if (newObject.additionalProperties && operand.additionalProperties) {
-      newObject.additionalProperties = {
-        type: "and",
-        and: [newObject.additionalProperties, operand.additionalProperties]
-      };
-    } else if (operand.additionalProperties) {
-      newObject.additionalProperties = operand.additionalProperties;
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+function simpleTransformGenerator(typeToTransform, capabilityToTransform, functionToRun) {
+  const walker = (n, capability) => {
+    var _a;
+    if (capability === capabilityToTransform) {
+      let node = __spreadValues$1({}, n);
+      if (node.type === typeToTransform) {
+        node = functionToRun(node);
+      }
+      if (node.type === "object") {
+        const newObjectProperties = {};
+        for (const key in node.properties) {
+          const value = node.properties[key];
+          newObjectProperties[key] = {
+            required: value.required,
+            node: walker(value.node, capability)
+          };
+        }
+        return __spreadProps$1(__spreadValues$1({}, node), {
+          properties: __spreadValues$1({}, newObjectProperties),
+          extends: node.extends ? walker(node.extends, capability) : void 0,
+          additionalProperties: node.additionalProperties ? walker(node.additionalProperties, capability) : false
+        });
+      }
+      if (node.type === "array") {
+        return __spreadProps$1(__spreadValues$1({}, node), {
+          elementType: walker(node.elementType, capability)
+        });
+      }
+      if (node.type === "and") {
+        return __spreadProps$1(__spreadValues$1({}, node), {
+          and: node.and.map((element) => walker(element, capability))
+        });
+      }
+      if (node.type === "or") {
+        return __spreadProps$1(__spreadValues$1({}, node), {
+          or: node.or.map((element) => walker(element, capability))
+        });
+      }
+      if (node.type === "ref") {
+        return __spreadProps$1(__spreadValues$1({}, node), {
+          genericArguments: (_a = node.genericArguments) == null ? void 0 : _a.map((arg) => walker(arg, capability))
+        });
+      }
+      if (node.type === "tuple") {
+        return __spreadProps$1(__spreadValues$1({}, node), {
+          elementTypes: node.elementTypes.map((type) => walker(type, capability)),
+          additionalItems: node.additionalItems ? walker(node.additionalItems, capability) : false
+        });
+      }
+      if (node.type === "function") {
+        return __spreadProps$1(__spreadValues$1({}, node), {
+          parameters: node.parameters.map((param) => {
+            return __spreadProps$1(__spreadValues$1({}, param), {
+              type: walker(param.type, capability),
+              default: param.default ? walker(param.default, capability) : void 0
+            });
+          }),
+          returnType: node.returnType ? walker(node.returnType, capability) : void 0
+        });
+      }
+      if (node.type === "record") {
+        return __spreadProps$1(__spreadValues$1({}, node), {
+          keyType: walker(node.keyType, capability),
+          valueType: walker(node.valueType, capability)
+        });
+      }
+      if (node.type === "conditional") {
+        return __spreadProps$1(__spreadValues$1({}, node), {
+          check: {
+            left: walker(node.check.left, capability),
+            right: walker(node.check.left, capability)
+          },
+          value: {
+            true: walker(node.value.true, capability),
+            false: walker(node.value.false, capability)
+          }
+        });
+      }
     }
-    return newObject;
-  }
+    return n;
+  };
+  return walker;
 }
 
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -409,7 +510,7 @@ var __async = (__this, __arguments, generator) => {
 class XLRSDK {
   constructor(customRegistry) {
     this.registry = customRegistry != null ? customRegistry : new BasicXLRRegistry();
-    this.validator = new XLRValidator(this.registry);
+    this.validator = new XLRValidator(this.getType.bind(this));
     this.tsWriter = new xlrConverters.TSWriter();
   }
   loadDefinitionsFromDisk(inputPath, filters, transforms) {
@@ -426,36 +527,39 @@ class XLRSDK {
       if ((filters == null ? void 0 : filters.capabilityFilter) && capabilityName.match(filters == null ? void 0 : filters.capabilityFilter))
         return;
       capabilityList.forEach((extensionName) => {
+        var _a2;
         if (!(filters == null ? void 0 : filters.typeFilter) || !extensionName.match(filters == null ? void 0 : filters.typeFilter)) {
           const cType = JSON.parse(fs__default["default"].readFileSync(path__default["default"].join(inputPath, "xlr", `${extensionName}.json`)).toString());
-          transforms == null ? void 0 : transforms.forEach((transform) => transform(cType, capabilityName));
-          const resolvedType = xlrUtils.fillInGenerics(cType);
-          this.registry.add(resolvedType, manifest.pluginName, capabilityName);
+          const effectiveType = (_a2 = transforms == null ? void 0 : transforms.reduce((typeAccumulator, transformFn) => transformFn(typeAccumulator, capabilityName), cType)) != null ? _a2 : cType;
+          this.registry.add(effectiveType, manifest.pluginName, capabilityName);
         }
       });
     });
   }
-  loadDefinitionsFromModule(inputPath, filters, transforms) {
+  loadDefinitionsFromModule(manifest, filters, transforms) {
     return __async(this, null, function* () {
       var _a;
-      const importManifest = yield (function (t) { return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(t)); }); })(path__default["default"].join(inputPath, "xlr", "manifest.js"));
-      const manifest = importManifest.default;
       (_a = Object.keys(manifest.capabilities)) == null ? void 0 : _a.forEach((capabilityName) => {
         if ((filters == null ? void 0 : filters.capabilityFilter) && capabilityName.match(filters == null ? void 0 : filters.capabilityFilter))
           return;
         const capabilityList = manifest.capabilities[capabilityName];
         capabilityList.forEach((extension) => {
+          var _a2;
           if (!(filters == null ? void 0 : filters.typeFilter) || !extension.name.match(filters == null ? void 0 : filters.typeFilter)) {
-            transforms == null ? void 0 : transforms.forEach((transform) => transform(extension, extension.name));
-            const resolvedType = xlrUtils.fillInGenerics(extension);
-            this.registry.add(resolvedType, manifest.pluginName, extension.name);
+            const effectiveType = (_a2 = transforms == null ? void 0 : transforms.reduce((typeAccumulator, transformFn) => transformFn(typeAccumulator, capabilityName), extension)) != null ? _a2 : extension;
+            this.registry.add(effectiveType, manifest.pluginName, capabilityName);
           }
         });
       });
     });
   }
-  getType(id) {
-    return this.registry.get(id);
+  getType(id, options) {
+    let type = this.registry.get(id);
+    if ((options == null ? void 0 : options.getRawType) === true || !type) {
+      return type;
+    }
+    type = this.resolveType(type);
+    return xlrUtils.fillInGenerics(type);
   }
   hasType(id) {
     return this.registry.has(id);
@@ -463,20 +567,28 @@ class XLRSDK {
   listTypes(filters) {
     return this.registry.list(filters);
   }
-  validate(typeName, rootNode) {
-    const xlr = this.registry.get(typeName);
+  getTypeInfo(id) {
+    return this.registry.info(id);
+  }
+  validateByName(typeName, rootNode) {
+    const xlr = this.getType(typeName, { getRawType: true });
     if (!xlr) {
       throw new Error(`Type ${typeName} does not exist in registry, can't validate`);
     }
     return this.validator.validateType(rootNode, xlr);
   }
+  validateByType(type, rootNode) {
+    return this.validator.validateType(rootNode, type);
+  }
   exportRegistry(exportType, importMap, filters, transforms) {
     const typesToExport = this.registry.list(filters).map((type) => {
-      transforms == null ? void 0 : transforms.forEach((transformFunction) => {
-        var _a;
-        return transformFunction(type, (_a = this.registry.info(type.name)) == null ? void 0 : _a.capability);
-      });
-      return type;
+      var _a;
+      const resolvedType = this.resolveType(type);
+      const effectiveType = (_a = transforms == null ? void 0 : transforms.reduce((typeAccumulator, transformFn) => {
+        var _a2;
+        return transformFn(typeAccumulator, (_a2 = this.registry.info(type.name)) == null ? void 0 : _a2.capability);
+      }, resolvedType)) != null ? _a : resolvedType;
+      return effectiveType;
     });
     if (exportType === "TypeScript") {
       const outputString = this.exportToTypeScript(typesToExport, importMap);
@@ -484,6 +596,23 @@ class XLRSDK {
     }
     throw new Error(`Unknown export format ${exportType}`);
   }
+  resolveType(type) {
+    return simpleTransformGenerator("object", "any", (objectNode) => {
+      if (objectNode.extends) {
+        const refName = objectNode.extends.ref.split("<")[0];
+        let extendedType = this.getType(refName, { getRawType: true });
+        if (!extendedType) {
+          throw new Error(`Error resolving ${objectNode.name}: can't find extended type ${refName}`);
+        }
+        extendedType = xlrUtils.resolveReferenceNode(objectNode.extends, extendedType);
+        return __spreadProps(__spreadValues({}, xlrUtils.computeEffectiveObject(extendedType, objectNode, false)), {
+          name: objectNode.name,
+          description: objectNode.description
+        });
+      }
+      return objectNode;
+    })(type, "any");
+  }
   exportToTypeScript(typesToExport, importMap) {
     const referencedImports = new Set();
     const exportedTypes = new Map();
@@ -500,7 +629,7 @@ class XLRSDK {
     importMap.forEach((imports, packageName) => {
       const applicableImports = imports.filter((i) => referencedImports.has(i));
       resultFile = ts__default["default"].factory.updateSourceFile(resultFile, [
-        ts__default["default"].factory.createImportDeclaration(void 0, void 0, ts__default["default"].factory.createImportClause(false, void 0, ts__default["default"].factory.createNamedImports(applicableImports.map((i) => ts__default["default"].factory.createImportSpecifier(false, void 0, ts__default["default"].factory.createIdentifier(i))))), ts__default["default"].factory.createStringLiteral(packageName)),
+        ts__default["default"].factory.createImportDeclaration(void 0, ts__default["default"].factory.createImportClause(false, void 0, ts__default["default"].factory.createNamedImports(applicableImports.map((i) => ts__default["default"].factory.createImportSpecifier(false, void 0, ts__default["default"].factory.createIdentifier(i))))), ts__default["default"].factory.createStringLiteral(packageName)),
         ...resultFile.statements
       ]);
     });
@@ -511,61 +640,6 @@ ${nodeText}`;
   }
 }
 
-function simpleTransformGenerator(typeToTransform, capabilityToTransform, functionToRun) {
-  const walker = (node, capability) => {
-    var _a;
-    if (capability === capabilityToTransform) {
-      if (node.type === typeToTransform) {
-        functionToRun(node);
-      }
-      if (node.type === "object") {
-        if (node.extends) {
-          walker(node, capability);
-        }
-        for (const key in node.properties) {
-          const value = node.properties[key];
-          walker(value.node, capability);
-        }
-        if (node.additionalProperties) {
-          walker(node.additionalProperties, capability);
-        }
-      } else if (node.type === "array") {
-        walker(node.elementType, capability);
-      } else if (node.type === "and") {
-        node.and.forEach((element) => walker(element, capability));
-      } else if (node.type === "or") {
-        node.or.forEach((element) => walker(element, capability));
-      } else if (node.type === "ref") {
-        (_a = node.genericArguments) == null ? void 0 : _a.forEach((element) => walker(element, capability));
-      } else if (node.type === "tuple") {
-        if (node.additionalItems) {
-          walker(node.additionalItems, capability);
-        }
-        node.elementTypes.forEach((element) => walker(element, capability));
-      } else if (node.type === "function") {
-        node.parameters.forEach((param) => {
-          walker(param.type, capability);
-          if (param.default) {
-            walker(param.default, capability);
-          }
-        });
-        if (node.returnType) {
-          walker(node.returnType, capability);
-        }
-      } else if (node.type === "record") {
-        walker(node.keyType, capability);
-        walker(node.valueType, capability);
-      } else if (node.type === "conditional") {
-        walker(node.check.left, capability);
-        walker(node.check.right, capability);
-        walker(node.value.true, capability);
-        walker(node.value.false, capability);
-      }
-    }
-  };
-  return walker;
-}
-
 exports.BasicXLRRegistry = BasicXLRRegistry;
 exports.XLRSDK = XLRSDK;
 exports.simpleTransformGenerator = simpleTransformGenerator;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Node } from 'jsonc-parser';
-import { NamedType, NodeType, TransformFunction, NodeTypeStrings, NodeTypeMap } from '@player-tools/xlr';
+import { NamedType, NodeType, TransformFunction, TSManifest, NodeTypeStrings, NodeTypeMap } from '@player-tools/xlr';
 
 interface ValidationError {
     /** Error message text */
@@ -50,6 +50,10 @@ declare class BasicXLRRegistry implements XLRRegistry {
     info(id: string): TypeMetadata | undefined;
 }
 
+interface GetTypeOptions {
+    /** Resolves `extends` fields in objects */
+    getRawType?: boolean;
+}
 /**
  * Abstraction for interfacing with XLRs making it more approachable to use without understanding the inner workings of the types and how they are packaged
  */
@@ -58,12 +62,67 @@ declare class XLRSDK {
     private validator;
     private tsWriter;
     constructor(customRegistry?: XLRRegistry);
+    /**
+     * Loads definitions from a path on the filesystem
+     *
+     * @param inputPath - path to the directory to load (above the xlr folder)
+     * @param filters - Any filters to apply when loading the types (a positive match will omit)
+     * @param transforms - any transforms to apply to the types being loaded
+     */
     loadDefinitionsFromDisk(inputPath: string, filters?: Omit<Filters, 'pluginFilter'>, transforms?: Array<TransformFunction>): void;
-    loadDefinitionsFromModule(inputPath: string, filters?: Omit<Filters, 'pluginFilter'>, transforms?: Array<TransformFunction>): Promise<void>;
-    getType(id: string): NamedType<NodeType> | undefined;
+    /**
+     * Load definitions from a js/ts file in memory
+     *
+     * @param manifest - The imported XLR manifest module
+     * @param filters - Any filters to apply when loading the types (a positive match will omit)
+     * @param transforms - any transforms to apply to the types being loaded
+     */
+    loadDefinitionsFromModule(manifest: TSManifest, filters?: Omit<Filters, 'pluginFilter'>, transforms?: Array<TransformFunction>): Promise<void>;
+    /**
+     * Returns a Type that has been previously loaded
+     *
+     * @param id - Type to retrieve
+     * @param options - `GetTypeOptions`
+     * @returns `NamedType<NodeType>` | `undefined`
+     */
+    getType(id: string, options?: GetTypeOptions): NamedType<NodeType> | undefined;
+    /**
+     * Returns if a Type with `id` has been loaded into the DSK
+     *
+     * @param id - Type to retrieve
+     * @returns `boolean`
+     */
     hasType(id: string): boolean;
+    /**
+     * Lists types that have been loaded into the SDK
+     *
+     * @param filters - Any filters to apply to the types returned (a positive match will omit)
+     * @returns `Array<NamedTypes>`
+     */
     listTypes(filters?: Filters): NamedType<NodeType>[];
-    validate(typeName: string, rootNode: Node): ValidationError[];
+    /**
+     * Returns meta information around a registered type
+     *
+     * @param id - Name of Type to retrieve
+     * @returns `TypeMetaData` | `undefined`
+     */
+    getTypeInfo(id: string): TypeMetadata | undefined;
+    /**
+     * Validates if a JSONC Node follows the XLR Type registered under the `typeName` specified
+     *
+     * @param typeName - Registered XLR Type to use for validation
+     * @param rootNode - Node to validate
+     * @returns `Array<ValidationErrors>`
+     */
+    validateByName(typeName: string, rootNode: Node): ValidationError[];
+    /**
+     * Validates if a JSONC Node follows the supplied XLR Type
+     *
+     * @param type - Type to validate against
+     * @param rootNode - Node to validate
+     * @returns `Array<ValidationErrors>`
+     */
+    validateByType(type: NodeType, rootNode: Node): ValidationError[];
     /**
      * Exports the types loaded into the registry to the specified format
      *
@@ -74,6 +133,7 @@ declare class XLRSDK {
      * @returns [filename, content][] - Tuples of filenames and content to write
      */
     exportRegistry(exportType: ExportTypes, importMap: Map<string, string[]>, filters?: Filters, transforms?: Array<TransformFunction>): [string, string][];
+    private resolveType;
     private exportToTypeScript;
 }
 
@@ -81,6 +141,6 @@ declare class XLRSDK {
  * Helper function for simple transforms
  * Walks an XLR tree looking for the specified node type calls the supplied function when called
  */
-declare function simpleTransformGenerator<T extends NodeTypeStrings = NodeTypeStrings>(typeToTransform: T, capabilityToTransform: string, functionToRun: (input: NodeTypeMap[T]) => void): TransformFunction;
+declare function simpleTransformGenerator<T extends NodeTypeStrings = NodeTypeStrings>(typeToTransform: T, capabilityToTransform: string, functionToRun: (input: NodeTypeMap[T]) => NodeTypeMap[T]): TransformFunction;
 
-export { BasicXLRRegistry, ExportTypes, Filters, TypeMetadata, ValidationError, XLRRegistry, XLRSDK, simpleTransformGenerator };
+export { BasicXLRRegistry, ExportTypes, Filters, GetTypeOptions, TypeMetadata, ValidationError, XLRRegistry, XLRSDK, simpleTransformGenerator };