@player-tools/xlr-sdk 0.1.0 → 0.2.0

package/dist/index.cjs.js

@@ -231,29 +231,34 @@ class XLRValidator {
   validateObject(xlrNode, node) {
     const issues = [];
     const objectProps = xlrUtils.makePropertyMap(node);
-    for (const prop in xlrNode.properties) {
-      const expectedType = xlrNode.properties[prop];
+    let effectiveXLRNode = xlrNode;
+    if (xlrNode.extends) {
+      const extendedNode = this.getRefType(xlrNode.extends);
+      effectiveXLRNode = this.computeEffectiveObject(extendedNode, xlrNode);
+    }
+    for (const prop in effectiveXLRNode.properties) {
+      const expectedType = effectiveXLRNode.properties[prop];
       const valueNode = objectProps.get(prop);
       if (expectedType.required && valueNode === void 0) {
         issues.push({
           type: "missing",
           node,
-          message: `Property '${prop}' missing from type '${xlrNode.name}'`
+          message: `Property '${prop}' missing from type '${effectiveXLRNode.name}'`
         });
       }
       if (valueNode) {
         issues.push(...this.validateType(valueNode, expectedType.node));
       }
     }
-    const extraKeys = Array.from(objectProps.keys()).filter((key) => xlrNode.properties[key] === void 0);
-    if (xlrNode.additionalProperties === false && extraKeys.length > 0) {
+    const extraKeys = Array.from(objectProps.keys()).filter((key) => effectiveXLRNode.properties[key] === void 0);
+    if (effectiveXLRNode.additionalProperties === false && extraKeys.length > 0) {
       issues.push({
         type: "value",
         node,
-        message: `Unexpected properties on '${xlrNode.name}': ${extraKeys.join(", ")}`
+        message: `Unexpected properties on '${effectiveXLRNode.name}': ${extraKeys.join(", ")}`
       });
     } else {
-      issues.push(...extraKeys.flatMap((key) => this.validateType(objectProps.get(key), xlrNode.additionalProperties)));
+      issues.push(...extraKeys.flatMap((key) => this.validateType(objectProps.get(key), effectiveXLRNode.additionalProperties)));
     }
     return issues;
   }
@@ -357,13 +362,15 @@ class XLRValidator {
   }
   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: `${base.name} & ${operand.name}`,
-      description: `Effective type combining ${base.name} and ${operand.name}`
+      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 ${(_a = base.name) != null ? _a : "object literal"} and ${(_b = operand.name) != null ? _b : "object literal"} because of conflicting properties ${property}`);
+        throw new Error(`Can't compute effective type for ${baseObjectName} and ${operandObjectName} because of conflicting properties ${property}`);
       }
       newObject.properties[property] = operand.properties[property];
     }
@@ -504,6 +511,62 @@ ${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;
 //# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Node } from 'jsonc-parser';
-import { NamedType, NodeType, TransformFunction } from '@player-tools/xlr';
+import { NamedType, NodeType, TransformFunction, NodeTypeStrings, NodeTypeMap } from '@player-tools/xlr';
 
 interface ValidationError {
     /** Error message text */
@@ -77,4 +77,10 @@ declare class XLRSDK {
     private exportToTypeScript;
 }
 
-export { BasicXLRRegistry, ExportTypes, Filters, TypeMetadata, ValidationError, XLRRegistry, 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;
+
+export { BasicXLRRegistry, ExportTypes, Filters, TypeMetadata, ValidationError, XLRRegistry, XLRSDK, simpleTransformGenerator };

package/dist/index.esm.js

@@ -203,29 +203,34 @@ class XLRValidator {
   validateObject(xlrNode, node) {
     const issues = [];
     const objectProps = makePropertyMap(node);
-    for (const prop in xlrNode.properties) {
-      const expectedType = xlrNode.properties[prop];
+    let effectiveXLRNode = xlrNode;
+    if (xlrNode.extends) {
+      const extendedNode = this.getRefType(xlrNode.extends);
+      effectiveXLRNode = this.computeEffectiveObject(extendedNode, xlrNode);
+    }
+    for (const prop in effectiveXLRNode.properties) {
+      const expectedType = effectiveXLRNode.properties[prop];
       const valueNode = objectProps.get(prop);
       if (expectedType.required && valueNode === void 0) {
         issues.push({
           type: "missing",
           node,
-          message: `Property '${prop}' missing from type '${xlrNode.name}'`
+          message: `Property '${prop}' missing from type '${effectiveXLRNode.name}'`
         });
       }
       if (valueNode) {
         issues.push(...this.validateType(valueNode, expectedType.node));
       }
     }
-    const extraKeys = Array.from(objectProps.keys()).filter((key) => xlrNode.properties[key] === void 0);
-    if (xlrNode.additionalProperties === false && extraKeys.length > 0) {
+    const extraKeys = Array.from(objectProps.keys()).filter((key) => effectiveXLRNode.properties[key] === void 0);
+    if (effectiveXLRNode.additionalProperties === false && extraKeys.length > 0) {
       issues.push({
         type: "value",
         node,
-        message: `Unexpected properties on '${xlrNode.name}': ${extraKeys.join(", ")}`
+        message: `Unexpected properties on '${effectiveXLRNode.name}': ${extraKeys.join(", ")}`
       });
     } else {
-      issues.push(...extraKeys.flatMap((key) => this.validateType(objectProps.get(key), xlrNode.additionalProperties)));
+      issues.push(...extraKeys.flatMap((key) => this.validateType(objectProps.get(key), effectiveXLRNode.additionalProperties)));
     }
     return issues;
   }
@@ -329,13 +334,15 @@ class XLRValidator {
   }
   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: `${base.name} & ${operand.name}`,
-      description: `Effective type combining ${base.name} and ${operand.name}`
+      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 ${(_a = base.name) != null ? _a : "object literal"} and ${(_b = operand.name) != null ? _b : "object literal"} because of conflicting properties ${property}`);
+        throw new Error(`Can't compute effective type for ${baseObjectName} and ${operandObjectName} because of conflicting properties ${property}`);
       }
       newObject.properties[property] = operand.properties[property];
     }
@@ -476,5 +483,60 @@ ${nodeText}`;
   }
 }
 
-export { BasicXLRRegistry, XLRSDK };
+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.1.0",
+  "version": "0.2.0",
   "private": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
@@ -9,9 +9,9 @@
     "typescript": "4.4.4"
   },
   "dependencies": {
-    "@player-tools/xlr": "0.1.0",
-    "@player-tools/xlr-utils": "0.1.0",
-    "@player-tools/xlr-converters": "0.1.0",
+    "@player-tools/xlr": "0.2.0",
+    "@player-tools/xlr-utils": "0.2.0",
+    "@player-tools/xlr-converters": "0.2.0",
     "jsonc-parser": "^2.3.1",
     "@types/node": "^16.11.12",
     "@types/fs-extra": "^9.0.13",

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from './sdk';
 export * from './types';
 export * from './registry';
+export * from './utils';

package/src/utils.ts

@@ -0,0 +1,85 @@
+/* eslint-disable guard-for-in */
+/* eslint-disable no-restricted-syntax */
+import type {
+  NamedType,
+  NodeTypeStrings,
+  NodeTypeMap,
+  TransformFunction,
+  NodeType,
+} from '@player-tools/xlr';
+
+/**
+ * Helper function for simple transforms
+ * Walks an XLR tree looking for the specified node type calls the supplied function when called
+ */
+export function simpleTransformGenerator<
+  T extends NodeTypeStrings = NodeTypeStrings
+>(
+  typeToTransform: T,
+  capabilityToTransform: string,
+  functionToRun: (input: NodeTypeMap[T]) => void
+): TransformFunction {
+  /** walker for an XLR tree to touch every node */
+  const walker: TransformFunction = (
+    node: NamedType | NodeType,
+    capability: string
+  ) => {
+    // Run transform on base node before running on children
+    if (capability === capabilityToTransform) {
+      if (node.type === typeToTransform) {
+        functionToRun(node as unknown as NodeTypeMap[T]);
+      }
+
+      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') {
+        node.genericArguments?.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;
+}

package/src/validator.ts

@@ -169,15 +169,23 @@ export class XLRValidator {
   private validateObject(xlrNode: ObjectType, node: Node) {
     const issues: Array<ValidationError> = [];
     const objectProps = makePropertyMap(node);
+
+    let effectiveXLRNode = xlrNode;
+
+    if (xlrNode.extends) {
+      const extendedNode = this.getRefType(xlrNode.extends) as ObjectType;
+      effectiveXLRNode = this.computeEffectiveObject(extendedNode, xlrNode);
+    }
+
     // eslint-disable-next-line guard-for-in, no-restricted-syntax
-    for (const prop in xlrNode.properties) {
-      const expectedType = xlrNode.properties[prop];
+    for (const prop in effectiveXLRNode.properties) {
+      const expectedType = effectiveXLRNode.properties[prop];
       const valueNode = objectProps.get(prop);
       if (expectedType.required && valueNode === undefined) {
         issues.push({
           type: 'missing',
           node,
-          message: `Property '${prop}' missing from type '${xlrNode.name}'`,
+          message: `Property '${prop}' missing from type '${effectiveXLRNode.name}'`,
         });
       }
 
@@ -190,22 +198,25 @@ export class XLRValidator {
 
     // Check if unknown keys are allowed and if they are - do the violate the constraint
     const extraKeys = Array.from(objectProps.keys()).filter(
-      (key) => xlrNode.properties[key] === undefined
+      (key) => effectiveXLRNode.properties[key] === undefined
     );
-    if (xlrNode.additionalProperties === false && extraKeys.length > 0) {
+    if (
+      effectiveXLRNode.additionalProperties === false &&
+      extraKeys.length > 0
+    ) {
       issues.push({
         type: 'value',
         node,
-        message: `Unexpected properties on '${xlrNode.name}': ${extraKeys.join(
-          ', '
-        )}`,
+        message: `Unexpected properties on '${
+          effectiveXLRNode.name
+        }': ${extraKeys.join(', ')}`,
       });
     } else {
       issues.push(
         ...extraKeys.flatMap((key) =>
           this.validateType(
             objectProps.get(key) as Node,
-            xlrNode.additionalProperties as NodeType
+            effectiveXLRNode.additionalProperties as NodeType
           )
         )
       );
@@ -358,10 +369,12 @@ export class XLRValidator {
     operand: ObjectType,
     errorOnOverlap = true
   ): ObjectType {
+    const baseObjectName = base.name ?? 'object literal';
+    const operandObjectName = operand.name ?? 'object literal';
     const newObject = {
       ...base,
-      name: `${base.name} & ${operand.name}`,
-      description: `Effective type combining ${base.name} and ${operand.name}`,
+      name: `${baseObjectName} & ${operandObjectName}`,
+      description: `Effective type combining ${baseObjectName} and ${operandObjectName}`,
     };
 
     // eslint-disable-next-line no-restricted-syntax, guard-for-in
@@ -373,11 +386,7 @@ export class XLRValidator {
         errorOnOverlap
       ) {
         throw new Error(
-          `Can't compute effective type for ${
-            base.name ?? 'object literal'
-          } and ${
-            operand.name ?? 'object literal'
-          } because of conflicting properties ${property}`
+          `Can't compute effective type for ${baseObjectName} and ${operandObjectName} because of conflicting properties ${property}`
         );
       }