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

package/dist/index.esm.js

@@ -1,22 +1,22 @@
-import { isPrimitiveTypeNode, resolveConditional, makePropertyMap, isGenericNodeType, fillInGenerics } from '@player-tools/xlr-utils';
+import { isPrimitiveTypeNode, resolveConditional, makePropertyMap, computeEffectiveObject, resolveReferenceNode, fillInGenerics } from '@player-tools/xlr-utils';
 import { TSWriter } from '@player-tools/xlr-converters';
 import fs from 'fs';
 import path from 'path';
 import ts from 'typescript';
 
-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;
 };
@@ -28,7 +28,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);
@@ -68,28 +68,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) {
@@ -130,7 +130,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) => {
@@ -166,11 +166,24 @@ class XLRValidator {
         }
       }
     } else if (xlrNode.type === "conditional") {
-      const resolvedType = 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 = 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}`);
     }
@@ -206,7 +219,7 @@ class XLRValidator {
     let effectiveXLRNode = xlrNode;
     if (xlrNode.extends) {
       const extendedNode = this.getRefType(xlrNode.extends);
-      effectiveXLRNode = this.computeEffectiveObject(extendedNode, xlrNode);
+      effectiveXLRNode = computeEffectiveObject(extendedNode, xlrNode);
     }
     for (const prop in effectiveXLRNode.properties) {
       const expectedType = effectiveXLRNode.properties[prop];
@@ -267,19 +280,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 && 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 fillInGenerics(actualType, genericMap);
+    return resolveReferenceNode(ref, actualType);
   }
   getRegex(expString) {
     if (this.regexCache.has(expString)) {
@@ -297,6 +305,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 {
@@ -304,6 +318,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);
       }
@@ -312,15 +333,15 @@ class XLRValidator {
       }
       if (typeToApply.type === "object") {
         if (effectiveType.type === "object") {
-          effectiveType = this.computeEffectiveObject(effectiveType, typeToApply);
+          effectiveType = 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 {
@@ -332,32 +353,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) => {
@@ -381,7 +500,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 TSWriter();
   }
   loadDefinitionsFromDisk(inputPath, filters, transforms) {
@@ -398,36 +517,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.readFileSync(path.join(inputPath, "xlr", `${extensionName}.json`)).toString());
-          transforms == null ? void 0 : transforms.forEach((transform) => transform(cType, capabilityName));
-          const resolvedType = 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 import(path.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 = 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 fillInGenerics(type);
   }
   hasType(id) {
     return this.registry.has(id);
@@ -435,20 +557,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);
@@ -456,6 +586,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 = resolveReferenceNode(objectNode.extends, extendedType);
+        return __spreadProps(__spreadValues({}, 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();
@@ -472,7 +619,7 @@ class XLRSDK {
     importMap.forEach((imports, packageName) => {
       const applicableImports = imports.filter((i) => referencedImports.has(i));
       resultFile = ts.factory.updateSourceFile(resultFile, [
-        ts.factory.createImportDeclaration(void 0, void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports(applicableImports.map((i) => ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier(i))))), ts.factory.createStringLiteral(packageName)),
+        ts.factory.createImportDeclaration(void 0, ts.factory.createImportClause(false, void 0, ts.factory.createNamedImports(applicableImports.map((i) => ts.factory.createImportSpecifier(false, void 0, ts.factory.createIdentifier(i))))), ts.factory.createStringLiteral(packageName)),
         ...resultFile.statements
       ]);
     });
@@ -483,60 +630,5 @@ ${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;
-}
-
 export { BasicXLRRegistry, XLRSDK, simpleTransformGenerator };
 //# sourceMappingURL=index.esm.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@player-tools/xlr-sdk",
-  "version": "0.2.1-next.4",
+  "version": "0.2.1",
   "private": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
@@ -9,9 +9,9 @@
     "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-converters": "0.2.1-next.4",
+    "@player-tools/xlr": "0.2.1",
+    "@player-tools/xlr-utils": "0.2.1",
+    "@player-tools/xlr-converters": "0.2.1",
     "jsonc-parser": "^2.3.1",
     "@types/node": "^16.11.12",
     "@types/fs-extra": "^9.0.13",

package/src/registry/basic-registry.ts

@@ -73,7 +73,6 @@ export class BasicXLRRegistry implements XLRRegistry {
         });
       }
     });
-
     return validTypes.map((type) => this.get(type) as NamedType);
   }