@player-tools/json-language-service 0.13.0-next.3 → 0.13.0-next.5

package/dist/index.mjs

@@ -686,6 +686,19 @@ function mapFlowStateToType(flowType) {
   }
   return flowXLR;
 }
+var findErrorNode = (rootNode, nodeToFind) => {
+  const children = [rootNode];
+  while (children.length > 0) {
+    const child = children.pop();
+    if (child.jsonNode === nodeToFind) {
+      return child;
+    }
+    if (child.children) {
+      children.push(...child.children);
+    }
+  }
+  return rootNode;
+};
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/plugins/asset-wrapper-array-plugin.ts
 var isInView = (node) => {
@@ -937,19 +950,6 @@ import {
 function isError(issue) {
   return issue.severity === DiagnosticSeverity3.Error;
 }
-var findErrorNode = (rootNode, nodeToFind) => {
-  const children = [rootNode];
-  while (children.length > 0) {
-    const child = children.pop();
-    if (child.jsonNode === nodeToFind) {
-      return child;
-    }
-    if (child.children) {
-      children.push(...child.children);
-    }
-  }
-  return rootNode;
-};
 var translateSeverity = (severity) => {
   return severity;
 };
@@ -1201,8 +1201,409 @@ var XLRPlugin = class {
   }
 };
 
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/plugins/duplicate-id-plugin.ts
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/plugins/schema-validation-plugin.ts
 import { DiagnosticSeverity as DiagnosticSeverity4 } from "vscode-languageserver-types";
+import { isObjectType, isPrimitiveTypeNode } from "@player-tools/xlr-utils";
+function formatErrorMessage(message) {
+  return `Schema Validation Error: ${message}`;
+}
+function makeValidationRefObject(baseObject, validationFunction) {
+  return {
+    ...baseObject,
+    properties: {
+      ...baseObject.properties,
+      ...validationFunction.properties
+    },
+    additionalProperties: false
+  };
+}
+function validateSchemaValidations(validationNode, sdk, validationContext) {
+  const claimedValidator = getProperty(validationNode, "type");
+  if (!claimedValidator) {
+    validationContext.addViolation({
+      node: validationNode,
+      message: formatErrorMessage('Validation object missing "type" property'),
+      severity: DiagnosticSeverity4.Error
+    });
+  } else if (claimedValidator.valueNode?.type !== "string") {
+    validationContext.addViolation({
+      node: claimedValidator.valueNode ?? validationNode,
+      message: formatErrorMessage("Validation type must be a string"),
+      severity: DiagnosticSeverity4.Error
+    });
+  } else {
+    const validationXLR = sdk.getType(claimedValidator.valueNode.value, {
+      getRawType: true
+    });
+    if (!validationXLR) {
+      validationContext.addViolation({
+        node: validationNode,
+        message: formatErrorMessage(
+          `Validation Function ${claimedValidator} is not a registered validator`
+        ),
+        severity: DiagnosticSeverity4.Error
+      });
+    } else {
+      const valRef = sdk.getType("Validation.Reference", {
+        getRawType: true
+      });
+      if (valRef) {
+        let validationIssues;
+        const validatorFunctionProps = validationXLR.genericArguments?.[0];
+        if (!validatorFunctionProps || isObjectType(validatorFunctionProps)) {
+          validationIssues = sdk.validateByType(
+            makeValidationRefObject(
+              valRef,
+              validatorFunctionProps ?? {}
+            ),
+            validationNode.jsonNode
+          );
+          validationIssues.forEach((issue) => {
+            validationContext.addViolation({
+              node: validationNode,
+              message: formatErrorMessage(issue.message),
+              severity: translateSeverity(issue.severity)
+            });
+          });
+        } else {
+          const validationResults = validatorFunctionProps.or.map((node) => {
+            if (isObjectType(node)) {
+              return sdk.validateByType(
+                makeValidationRefObject(valRef, node),
+                validationNode.jsonNode
+              );
+            } else {
+              validationIssues.forEach((issue) => {
+                validationContext.addViolation({
+                  node: validationNode,
+                  message: formatErrorMessage(
+                    `Internal Error - Validation function ${validationXLR.name} type argument is not an object`
+                  ),
+                  severity: DiagnosticSeverity4.Error
+                });
+              });
+              return null;
+            }
+          }).filter((o) => o !== null && Array.isArray(o) && o.length === 0);
+          if (validationResults.length !== 1) {
+            validationContext.addViolation({
+              node: validationNode,
+              message: formatErrorMessage(
+                `Validation function invalid function parameters for type ${validationXLR.name}`
+              ),
+              severity: DiagnosticSeverity4.Error
+            });
+          }
+        }
+      } else {
+        validationContext.addViolation({
+          node: validationNode,
+          message: formatErrorMessage(
+            "Validation.Reference from @player-ui/types is not loaded into SDK"
+          ),
+          severity: DiagnosticSeverity4.Error
+        });
+      }
+    }
+  }
+}
+function validateSchemaFormat(formatNode, sdk, validationContext) {
+  const claimedFormatter = getProperty(formatNode, "type");
+  if (!claimedFormatter) {
+    validationContext.addViolation({
+      node: formatNode,
+      message: formatErrorMessage('Format object missing "type" property'),
+      severity: DiagnosticSeverity4.Error
+    });
+  } else if (claimedFormatter.valueNode?.type !== "string") {
+    validationContext.addViolation({
+      node: claimedFormatter.valueNode ?? claimedFormatter,
+      message: formatErrorMessage("Format type must be a string"),
+      severity: DiagnosticSeverity4.Error
+    });
+  } else {
+    const formatterXLR = sdk.getType(claimedFormatter.valueNode.value, {
+      getRawType: true
+    });
+    if (!formatterXLR) {
+      validationContext.addViolation({
+        node: formatNode,
+        message: formatErrorMessage(
+          `Formatter ${claimedFormatter} is not a registered formatter`
+        ),
+        severity: DiagnosticSeverity4.Error
+      });
+    } else if (formatterXLR.genericArguments && formatterXLR.genericArguments.length === 3) {
+      const otherArgsXLR = formatterXLR.genericArguments[2];
+      const validationIssues = sdk.validateByType(
+        {
+          ...otherArgsXLR,
+          properties: {
+            ...otherArgsXLR.properties,
+            type: {
+              required: true,
+              node: {
+                type: "string",
+                const: claimedFormatter.valueNode.value
+              }
+            }
+          }
+        },
+        formatNode.jsonNode
+      );
+      validationIssues.forEach((issue) => {
+        validationContext.addViolation({
+          node: formatNode,
+          message: formatErrorMessage(issue.message),
+          severity: translateSeverity(issue.severity)
+        });
+      });
+    }
+  }
+}
+function getSchemaTypeNames(schemaObj) {
+  const names = /* @__PURE__ */ new Set();
+  for (const prop of schemaObj.properties) {
+    const key = prop.keyNode?.value;
+    if (typeof key === "string") {
+      names.add(key);
+    }
+  }
+  return names;
+}
+function validateDataTypeStructure(dataTypeNode, claimedDataType, sdk, validationContext) {
+  const validationProp = getProperty(dataTypeNode, "validation");
+  if (validationProp?.valueNode && validationProp.valueNode.type !== "array") {
+    validationContext.addViolation({
+      node: validationProp.valueNode,
+      message: formatErrorMessage(
+        'Schema.DataType "validation" must be an array.'
+      ),
+      severity: DiagnosticSeverity4.Error
+    });
+  } else if (validationProp?.valueNode) {
+    validationProp.valueNode.children?.forEach((valRef) => {
+      if (valRef && valRef.type === "object") {
+        validateSchemaValidations(valRef, sdk, validationContext);
+      } else {
+        validationContext.addViolation({
+          node: validationProp.valueNode ?? dataTypeNode,
+          message: formatErrorMessage(
+            'Schema.DataType "validation" must be an object.'
+          ),
+          severity: DiagnosticSeverity4.Error
+        });
+      }
+    });
+  }
+  const formatProp = getProperty(dataTypeNode, "format");
+  if (formatProp?.valueNode?.type === "object") {
+    validateSchemaFormat(formatProp.valueNode, sdk, validationContext);
+  } else {
+    if (formatProp) {
+      validationContext.addViolation({
+        node: formatProp?.valueNode ?? dataTypeNode,
+        message: formatErrorMessage(
+          'Schema.DataType "format" must be an object.'
+        ),
+        severity: DiagnosticSeverity4.Error
+      });
+    }
+  }
+  const defaultNode = claimedDataType.properties?.["default"]?.node;
+  const defaultProp = getProperty(dataTypeNode, "default");
+  if (defaultNode && defaultProp?.valueNode) {
+    if (isPrimitiveTypeNode(defaultNode)) {
+      if (defaultProp.valueNode.type !== defaultNode.type) {
+        validationContext.addViolation({
+          node: defaultProp.valueNode,
+          message: formatErrorMessage(
+            `Default value doesn't match the expected type of ${defaultNode.type} for type ${claimedDataType.name}`
+          ),
+          severity: DiagnosticSeverity4.Error
+        });
+      }
+    } else if (defaultNode.type === "or") {
+      if (!defaultNode.or.some((n) => n.type === defaultProp.valueNode?.type)) {
+        validationContext.addViolation({
+          node: defaultProp.valueNode,
+          message: formatErrorMessage(
+            `Default value doesn't match any of the expected types ${defaultNode.or.map((t) => t.type).join(", ")} for type ${claimedDataType.name}`
+          ),
+          severity: DiagnosticSeverity4.Error
+        });
+      }
+    } else {
+      validationContext.addViolation({
+        node: defaultProp.valueNode,
+        message: formatErrorMessage(
+          `Unknown default node type ${defaultNode.type}`
+        ),
+        severity: DiagnosticSeverity4.Error
+      });
+    }
+  }
+  const isArrayProp = getProperty(dataTypeNode, "isArray");
+  const isRecordProp = getProperty(dataTypeNode, "isRecord");
+  if (isArrayProp?.valueNode && isArrayProp.valueNode.type !== "boolean") {
+    validationContext.addViolation({
+      node: isArrayProp.valueNode,
+      message: formatErrorMessage(
+        'Schema.DataType "isArray" must be a boolean.'
+      ),
+      severity: DiagnosticSeverity4.Error
+    });
+  }
+  if (isRecordProp?.valueNode && isRecordProp.valueNode.type !== "boolean") {
+    validationContext.addViolation({
+      node: isRecordProp.valueNode,
+      message: formatErrorMessage(
+        'Schema.DataType "isRecord" must be a boolean.'
+      ),
+      severity: DiagnosticSeverity4.Error
+    });
+  }
+  if (isArrayProp?.valueNode && isRecordProp?.valueNode && isArrayProp.valueNode.value === true && isRecordProp.valueNode.value === true) {
+    validationContext.addViolation({
+      node: dataTypeNode,
+      message: formatErrorMessage(
+        'Schema.DataType cannot have both "isArray" and "isRecord" true.'
+      ),
+      severity: DiagnosticSeverity4.Error
+    });
+  }
+}
+function validateSchemaNode(node, schemaTypeNames, sdk, validationContext) {
+  for (const prop of node.properties) {
+    const valueNode = prop.valueNode;
+    if (!(valueNode && valueNode.type === "object")) {
+      if (valueNode) {
+        validationContext.addViolation({
+          node: valueNode,
+          message: formatErrorMessage(
+            `Schema property "${prop.keyNode.value}" must be an object (Schema.DataType) with a "type" field.`
+          ),
+          severity: DiagnosticSeverity4.Error
+        });
+      }
+      continue;
+    }
+    const dataTypeNode = valueNode;
+    const typeProp = getProperty(dataTypeNode, "type");
+    if (!typeProp) {
+      validationContext.addViolation({
+        node: valueNode,
+        message: formatErrorMessage(
+          'Schema.DataType must have a "type" property (reference to schema or XLR type).'
+        ),
+        severity: DiagnosticSeverity4.Error
+      });
+      continue;
+    }
+    const typeValueNode = typeProp.valueNode;
+    if (!typeValueNode || typeValueNode.type !== "string") {
+      validationContext.addViolation({
+        node: typeValueNode ?? typeProp,
+        message: formatErrorMessage(
+          'Schema "type" must be a string (schema type name or XLR type name).'
+        ),
+        severity: DiagnosticSeverity4.Error
+      });
+      continue;
+    }
+    const typeName = typeValueNode.value;
+    const isSchemaType = schemaTypeNames.has(typeName);
+    const XLRType = sdk.getType(typeName, { getRawType: true });
+    if (!isSchemaType && !XLRType) {
+      validationContext.addViolation({
+        node: typeValueNode,
+        message: formatErrorMessage(
+          `Unknown schema type "${typeName}". Type must be a schema type (key in this schema) or an XLR type loaded in the SDK.`
+        ),
+        severity: DiagnosticSeverity4.Error
+      });
+    } else if (XLRType) {
+      validateDataTypeStructure(
+        dataTypeNode,
+        XLRType,
+        sdk,
+        validationContext
+      );
+    }
+  }
+}
+function validateFlowSchema(contentNode, sdk, validationContext) {
+  const schemaProp = getProperty(contentNode, "schema");
+  if (!schemaProp?.valueNode) {
+    return;
+  }
+  const schemaValue = schemaProp.valueNode;
+  if (schemaValue.type !== "object") {
+    validationContext.addViolation({
+      node: schemaValue,
+      message: formatErrorMessage(
+        'Flow "schema" must be an object with at least a "ROOT" key.'
+      ),
+      severity: DiagnosticSeverity4.Error
+    });
+    return;
+  }
+  const schemaObj = schemaValue;
+  const hasRoot = schemaObj.properties.some((p) => p.keyNode.value === "ROOT");
+  if (!hasRoot) {
+    validationContext.addViolation({
+      node: schemaValue,
+      message: formatErrorMessage('Schema must have a "ROOT" key.'),
+      severity: DiagnosticSeverity4.Error
+    });
+  }
+  const schemaTypeNames = getSchemaTypeNames(schemaObj);
+  for (const prop of schemaObj.properties) {
+    const nodeValue = prop.valueNode;
+    if (!nodeValue || nodeValue.type !== "object") {
+      if (nodeValue) {
+        validationContext.addViolation({
+          node: nodeValue,
+          message: formatErrorMessage(
+            `Schema node "${prop.keyNode.value}" must be an object.`
+          ),
+          severity: DiagnosticSeverity4.Error
+        });
+      }
+      continue;
+    }
+    validateSchemaNode(
+      nodeValue,
+      schemaTypeNames,
+      sdk,
+      validationContext
+    );
+  }
+}
+var SchemaValidationPlugin = class {
+  name = "schema-validation";
+  /** Resolved when CommonTypes have been loaded into the XLR SDK (once per plugin apply) */
+  commonTypesLoaded = null;
+  apply(service) {
+    service.hooks.validate.tap(this.name, async (_ctx, validationContext) => {
+      await this.commonTypesLoaded;
+      validationContext.useASTVisitor(
+        this.createValidationVisitor(service, validationContext)
+      );
+    });
+  }
+  createValidationVisitor(service, validationContext) {
+    const sdk = service.XLRService.XLRSDK;
+    return {
+      ContentNode: (contentNode) => {
+        validateFlowSchema(contentNode, sdk, validationContext);
+      }
+    };
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/plugins/duplicate-id-plugin.ts
+import { DiagnosticSeverity as DiagnosticSeverity5 } from "vscode-languageserver-types";
 var checkParentTemplate = (node, depth = 0) => {
   if (node.parent) {
     if (isPropertyNode(node.parent) && node.parent.keyNode.value === "template") {
@@ -1233,7 +1634,7 @@ var createViolation = (node) => {
   }
   return {
     node: valueNode,
-    severity: DiagnosticSeverity4.Error,
+    severity: DiagnosticSeverity5.Error,
     message: `The id "${node.id?.valueNode?.value}" is already in use in this view.`,
     fix: () => {
       return {
@@ -1275,7 +1676,7 @@ var createValidationVisitor2 = (ctx) => {
         if (missingIndexSegments.length !== 0) {
           ctx.addViolation({
             node: assetNode,
-            severity: DiagnosticSeverity4.Error,
+            severity: DiagnosticSeverity5.Error,
             message: `The id for this templated elements is missing the following index segments: ${missingIndexSegments.join(
               ", "
             )}`
@@ -1310,7 +1711,7 @@ var DuplicateIDPlugin = class {
 };
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/plugins/missing-asset-wrapper-plugin.ts
-import { DiagnosticSeverity as DiagnosticSeverity5 } from "vscode-languageserver-types";
+import { DiagnosticSeverity as DiagnosticSeverity6 } from "vscode-languageserver-types";
 var getObjectTarget = (node) => {
   if (isObjectNode(node)) {
     return node;
@@ -1346,7 +1747,7 @@ var MissingAssetWrapperPlugin = class {
             addFixableViolation(d, {
               node: originalNode,
               message: d.message,
-              severity: d.severity ?? DiagnosticSeverity5.Error,
+              severity: d.severity ?? DiagnosticSeverity6.Error,
               fix: () => ({
                 name: `Wrap in "asset"`,
                 edit: {
@@ -1372,7 +1773,7 @@ var MissingAssetWrapperPlugin = class {
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/plugins/nav-state-plugin.ts
 import {
   CompletionItemKind as CompletionItemKind3,
-  DiagnosticSeverity as DiagnosticSeverity6
+  DiagnosticSeverity as DiagnosticSeverity7
 } from "vscode-languageserver-types";
 var createValidationVisitor3 = (ctx) => {
   const validTransitions = /* @__PURE__ */ new Map();
@@ -1400,7 +1801,7 @@ var createValidationVisitor3 = (ctx) => {
           if (!validTransitions.get(flowNodeId)?.has(transitionObjects.valueNode.value)) {
             ctx.addViolation({
               node: transitionObjects.valueNode,
-              severity: DiagnosticSeverity6.Error,
+              severity: DiagnosticSeverity7.Error,
               message: `Node "${transitionObjects.valueNode.value}" not found`
             });
           }
@@ -1461,7 +1862,7 @@ var NavStatePlugin = class {
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/plugins/view-node-plugin.ts
 import {
   CompletionItemKind as CompletionItemKind4,
-  DiagnosticSeverity as DiagnosticSeverity7
+  DiagnosticSeverity as DiagnosticSeverity8
 } from "vscode-languageserver-types";
 var createValidationVisitor4 = (ctx, viewInfo) => {
   return {
@@ -1478,7 +1879,7 @@ var createValidationVisitor4 = (ctx, viewInfo) => {
         ctx.addViolation({
           node: refNode.valueNode,
           message: `View with id: ${refID} does not exist.`,
-          severity: DiagnosticSeverity7.Error
+          severity: DiagnosticSeverity8.Error
         });
       }
     },
@@ -1488,7 +1889,7 @@ var createValidationVisitor4 = (ctx, viewInfo) => {
           ctx.addViolation({
             node: viewNode.id.valueNode,
             message: `View is not reachable`,
-            severity: DiagnosticSeverity7.Warning
+            severity: DiagnosticSeverity8.Warning
           });
         }
       }
@@ -1588,7 +1989,7 @@ var ViewNodePlugin = class {
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/xlr/transforms.ts
 import { simpleTransformGenerator } from "@player-tools/xlr-sdk";
-import { isPrimitiveTypeNode } from "@player-tools/xlr-utils";
+import { isPrimitiveTypeNode as isPrimitiveTypeNode2 } from "@player-tools/xlr-utils";
 var applyCommonProps = (node, capability) => {
   return simpleTransformGenerator("object", ["Assets", "Views"], (xlrNode) => {
     if (!xlrNode.properties.applicability) {
@@ -1653,7 +2054,7 @@ var applyValueRefs = (node, capability) => {
             type: "ref",
             ref: "BindingRef"
           });
-        } else if (isPrimitiveTypeNode(value.node)) {
+        } else if (isPrimitiveTypeNode2(value.node)) {
           const newUnionType = {
             type: "or",
             description: value.node.description,
@@ -1721,6 +2122,7 @@ var PLUGINS = [
   new DuplicateIDPlugin(),
   new ViewNodePlugin(),
   new SchemaInfoPlugin(),
+  new SchemaValidationPlugin(),
   new AssetWrapperArrayPlugin(),
   new NavStatePlugin(),
   new MissingAssetWrapperPlugin(),
@@ -1738,6 +2140,7 @@ var TRANSFORM_FUNCTIONS = [
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/language/json-language-service/src/xlr/registry.ts
 import { BasicXLRRegistry } from "@player-tools/xlr-sdk";
+var SINGLE_INSTANCE_CAPABILITIES = ["DataTypes", "Formatters", "Validators"];
 var PlayerXLRRegistry = class extends BasicXLRRegistry {
   /** Keeps the mapping of how a type is referenced by Player to the underlying XLR */
   registrationMap;
@@ -1768,7 +2171,7 @@ var PlayerXLRRegistry = class extends BasicXLRRegistry {
       this.registrationMap.set(registeredName, type.name);
       registeredName = type.extends.genericArguments[0].const;
     }
-    if (this.registrationMap.has(registeredName)) {
+    if (this.registrationMap.has(registeredName) && !SINGLE_INSTANCE_CAPABILITIES.includes(capability)) {
       const current = this.registrationMap.get(registeredName);
       if (Array.isArray(current)) {
         current.push(registeredName);
@@ -2218,6 +2621,7 @@ export {
   applyTemplateProperty,
   applyValueRefs,
   containsRange,
+  findErrorNode,
   formatLikeNode,
   getContentNode,
   getLSLocationOfNode,