@player-tools/json-language-service 0.9.0 → 0.9.1--canary.196.4186

package/package.json

@@ -6,12 +6,12 @@
     "types"
   ],
   "name": "@player-tools/json-language-service",
-  "version": "0.9.0",
+  "version": "0.9.1--canary.196.4186",
   "main": "dist/cjs/index.cjs",
   "dependencies": {
-    "@player-tools/xlr": "0.9.0",
-    "@player-tools/xlr-sdk": "0.9.0",
-    "@player-tools/xlr-utils": "0.9.0",
+    "@player-tools/xlr": "0.9.1--canary.196.4186",
+    "@player-tools/xlr-sdk": "0.9.1--canary.196.4186",
+    "@player-tools/xlr-utils": "0.9.1--canary.196.4186",
     "@player-ui/player": "0.7.3",
     "change-case": "^4.1.1",
     "cross-fetch": "^3.0.5",

package/src/__tests__/__snapshots__/service.test.ts.snap

@@ -181,6 +181,20 @@ exports[`player language service > validation > throws AssetWrapper errors 1`] =
     },
     "severity": 1,
   },
+  {
+    "message": "Expected: AssetWrapper & object literal | StaticSwitch & object literal | DynamicSwitch & object literal",
+    "range": {
+      "end": {
+        "character": 16,
+        "line": 12,
+      },
+      "start": {
+        "character": 23,
+        "line": 8,
+      },
+    },
+    "severity": 3,
+  },
   {
     "message": "Implicit Array -> "collection" assets is not supported.",
     "range": {

package/src/plugins/__tests__/asset-wrapper-array-plugin.test.ts

@@ -57,6 +57,7 @@ describe("asset-wrapper-array-plugin", () => {
     expect(diags?.map((d) => d.message)).toMatchInlineSnapshot(`
       [
         "View Validation Error - value: Does not match any of the expected types for type: 'AssetWrapperOrSwitch'",
+        "Expected: AssetWrapper & object literal | StaticSwitch & object literal | DynamicSwitch & object literal",
         "Implicit Array -> "collection" assets is not supported.",
       ]
     `);
@@ -77,6 +78,20 @@ describe("asset-wrapper-array-plugin", () => {
           },
           "severity": 1,
         },
+        {
+          "message": "Expected: AssetWrapper & object literal | StaticSwitch & object literal | DynamicSwitch & object literal",
+          "range": {
+            "end": {
+              "character": 7,
+              "line": 23,
+            },
+            "start": {
+              "character": 21,
+              "line": 17,
+            },
+          },
+          "severity": 3,
+        },
         {
           "message": "Implicit Array -> "collection" assets is not supported.",
           "range": {

package/src/plugins/__tests__/duplicate-id-plugin.test.ts

@@ -32,6 +32,81 @@ const simpleDupIDDocument = toTextDocument(
   )
 );
 
+const dupIDDocumentWithTemplate = toTextDocument(
+  JSON.stringify(
+    {
+      id: "test",
+      views: [
+        {
+          id: "root",
+          type: "info",
+          primaryInfo: {
+            asset: {
+              id: "root-primaryInfo-collection",
+              type: "collection",
+              template: [
+                {
+                  data: "some.data",
+                  output: "values",
+                  value: {
+                    asset: {
+                      id: "root-primaryInfo-collection-values-collection",
+                      type: "collection",
+                      template: [
+                        {
+                          data: "some.other.data",
+                          output: "values",
+                          value: {
+                            asset: {
+                              id: "root-primaryInfo-collection-values-collection-values-text",
+                              type: "text",
+                              value: "something",
+                            },
+                          },
+                        },
+                        {
+                          data: "some.other.data",
+                          output: "values",
+                          value: {
+                            asset: {
+                              id: "root-primaryInfo-collection-values-_index_collection-values_index1_-text",
+                              type: "text",
+                              value: "something",
+                            },
+                          },
+                        },
+                      ],
+                    },
+                  },
+                },
+              ],
+            },
+          },
+        },
+      ],
+      navigation: {
+        BEGIN: "FLOW_1",
+        FLOW_1: {
+          VIEW_1: {
+            ref: "root",
+            state_type: "VIEW",
+            transitions: {
+              "*": "END_Done",
+            },
+          },
+          END_Done: {
+            state_type: "END",
+            outcome: "done",
+          },
+          startState: "VIEW_1",
+        },
+      },
+    },
+    null,
+    2
+  )
+);
+
 describe("duplicate-id-plugin", () => {
   let service: PlayerLanguageService;
 
@@ -63,6 +138,20 @@ describe("duplicate-id-plugin", () => {
     `);
   });
 
+  test("finds templates with missing index segments", async () => {
+    const validations = await service.validateTextDocument(
+      dupIDDocumentWithTemplate
+    );
+
+    expect(validations).toHaveLength(2);
+    expect(validations?.map((v) => v.message)).toMatchInlineSnapshot(`
+      [
+        "The id for this templated elements is missing the following index segments: _index_",
+        "The id for this templated elements is missing the following index segments: _index_, _index1_",
+      ]
+    `);
+  });
+
   test("fixes dup ids", async () => {
     const diags = await service.validateTextDocument(simpleDupIDDocument);
 

package/src/plugins/__tests__/missing-asset-wrapper-plugin.test.ts

@@ -56,10 +56,11 @@ describe("missing-asset-wrapper", () => {
       simpleAssetWrapperDocument
     );
 
-    expect(validations).toHaveLength(1);
+    expect(validations).toHaveLength(2);
     expect(validations?.map((v) => v.message)).toMatchInlineSnapshot(`
       [
         "View Validation Error - value: Does not match any of the expected types for type: 'AssetWrapperOrSwitch'",
+        "Expected: AssetWrapper & object literal | StaticSwitch & object literal | DynamicSwitch & object literal",
       ]
     `);
   });
@@ -85,6 +86,20 @@ describe("missing-asset-wrapper", () => {
           },
           "severity": 1,
         },
+        {
+          "message": "Expected: AssetWrapper & object literal | StaticSwitch & object literal | DynamicSwitch & object literal",
+          "range": {
+            "end": {
+              "character": 7,
+              "line": 22,
+            },
+            "start": {
+              "character": 15,
+              "line": 18,
+            },
+          },
+          "severity": 3,
+        },
       ]
     `);
 

package/src/plugins/duplicate-id-plugin.ts

@@ -1,9 +1,27 @@
 import { DiagnosticSeverity } from "vscode-languageserver-types";
 import type { AssetASTNode, ASTNode, ViewASTNode } from "../parser";
-import { getViewNode, replaceString } from "../parser";
+import { getViewNode, isPropertyNode, replaceString } from "../parser";
 import type { PlayerLanguageService, PlayerLanguageServicePlugin } from "..";
 import type { Violation, ValidationContext, ASTVisitor } from "../types";
 
+/** Recurse up tree from node to find how many parents are templates */
+const checkParentTemplate = (node: ASTNode, depth = 0) => {
+  if (node.parent) {
+    if (
+      isPropertyNode(node.parent) &&
+      node.parent.keyNode.value === "template"
+    ) {
+      // Increase the template count each time it finds a nested template
+
+      depth += 1;
+
+      return checkParentTemplate(node.parent, depth);
+    }
+    return checkParentTemplate(node.parent, depth);
+  }
+  return depth;
+};
+
 /** Create an id for the node given it's path */
 const generateID = (node?: ASTNode): string => {
   if (!node || node.type === "view") {
@@ -84,6 +102,28 @@ const createValidationVisitor = (ctx: ValidationContext): ASTVisitor => {
       const assetIDMap = viewInfo.get(view);
       const idInfo = assetIDMap?.get(id);
 
+      const templateDepth = checkParentTemplate(assetNode);
+
+      if (templateDepth > 0) {
+        const expectedIndexElements = [];
+        for (let i = 0; i < templateDepth; i++) {
+          expectedIndexElements.push(`_index${i === 0 ? "" : i}_`);
+        }
+        const missingIndexSegments = expectedIndexElements.filter(
+          (e) => !id.includes(e)
+        );
+
+        if (missingIndexSegments.length !== 0) {
+          ctx.addViolation({
+            node: assetNode,
+            severity: DiagnosticSeverity.Error,
+            message: `The id for this templated elements is missing the following index segments: ${missingIndexSegments.join(
+              ", "
+            )}`,
+          });
+        }
+      }
+
       if (idInfo) {
         if (!idInfo.handled) {
           const origViolation = createViolation(idInfo.original);

package/src/plugins/xlr-plugin.ts

@@ -1,5 +1,6 @@
 import type { NodeType } from "@player-tools/xlr";
-import type { XLRSDK } from "@player-tools/xlr-sdk";
+import type { ValidationMessage } from "@player-tools/xlr-sdk";
+import { ValidationSeverity, XLRSDK } from "@player-tools/xlr-sdk";
 import type { CompletionItem } from "vscode-languageserver-types";
 import {
   CompletionItemKind,
@@ -17,6 +18,10 @@ import { mapFlowStateToType } from "../utils";
 import type { ASTNode, ObjectASTNode } from "../parser";
 import type { EnhancedDocumentContextWithPosition } from "../types";
 
+function isError(issue: ValidationMessage): boolean {
+  return issue.severity === DiagnosticSeverity.Error;
+}
+
 /** BFS search to find a JSONC node in children of some AST Node */
 const findErrorNode = (rootNode: ASTNode, nodeToFind: Node): ASTNode => {
   const children: Array<ASTNode> = [rootNode];
@@ -36,6 +41,16 @@ const findErrorNode = (rootNode: ASTNode, nodeToFind: Node): ASTNode => {
   return rootNode;
 };
 
+/**
+ * Translates an SDK severity level to an LSP severity level
+ * Relies on both levels having the values associated to the underlying levels
+ */
+const translateSeverity = (
+  severity: ValidationSeverity
+): DiagnosticSeverity => {
+  return severity as DiagnosticSeverity;
+};
+
 /**
  * Create Validation walkers
  */
@@ -65,13 +80,17 @@ function createValidationVisitor(
         assetNode.jsonNode
       );
       validationIssues.forEach((issue) => {
-        if (!nodesWithErrors.has(issue.node) || issue.type === "missing") {
-          nodesWithErrors.add(issue.node);
+        if (!(nodesWithErrors.has(issue.node) && isError(issue))) {
           ctx.addViolation({
             node: findErrorNode(assetNode, issue.node),
-            message: `Asset Validation Error - ${issue.type}: ${issue.message}`,
-            severity: DiagnosticSeverity.Error,
+            message: isError(issue)
+              ? `Asset Validation Error - ${issue.type}: ${issue.message}`
+              : issue.message,
+            severity: translateSeverity(issue.severity),
           });
+          if (isError(issue)) {
+            nodesWithErrors.add(issue.node);
+          }
         }
       });
     },
@@ -92,13 +111,17 @@ function createValidationVisitor(
         viewNode.jsonNode
       );
       validationIssues.forEach((issue) => {
-        if (!nodesWithErrors.has(issue.node) || issue.type === "missing") {
-          nodesWithErrors.add(issue.node);
+        if (!(nodesWithErrors.has(issue.node) && isError(issue))) {
           ctx.addViolation({
             node: findErrorNode(viewNode, issue.node),
-            message: `View Validation Error - ${issue.type}: ${issue.message}`,
-            severity: DiagnosticSeverity.Error,
+            message: isError(issue)
+              ? `View Validation Error - ${issue.type}: ${issue.message}`
+              : issue.message,
+            severity: translateSeverity(issue.severity),
           });
+          if (isError(issue)) {
+            nodesWithErrors.add(issue.node);
+          }
         }
       });
     },

package/src/xlr/__tests__/__snapshots__/transform.test.ts.snap

@@ -339,10 +339,24 @@ exports[`Transform Tests > applyValueRefs Transform 1`] = `
     },
     "type": {
       "node": {
-        "const": "mock",
         "description": "The asset type determines the semantics of how a user interacts with a page",
-        "title": "Asset.type",
-        "type": "string",
+        "or": [
+          {
+            "const": "mock",
+            "description": "The asset type determines the semantics of how a user interacts with a page",
+            "title": "Asset.type",
+            "type": "string",
+          },
+          {
+            "ref": "ExpressionRef",
+            "type": "ref",
+          },
+          {
+            "ref": "BindingRef",
+            "type": "ref",
+          },
+        ],
+        "type": "or",
       },
       "required": true,
     },

package/src/xlr/transforms.ts

@@ -78,45 +78,49 @@ export const applyAssetWrapperOrSwitch: TransformFunction = (
  * Modifies any primitive type property node (except id/type) to be Bindings or Expressions
  */
 export const applyValueRefs: TransformFunction = (node, capability) => {
-  return simpleTransformGenerator("object", "Assets", (inputNode) => {
-    const xlrNode = { ...inputNode };
-    for (const key in xlrNode.properties) {
-      if (key === "id" || key === "type") {
-        continue;
-      }
+  return simpleTransformGenerator(
+    "object",
+    ["Assets", "Views"],
+    (inputNode) => {
+      const xlrNode = { ...inputNode };
+      for (const key in xlrNode.properties) {
+        if (key === "id") {
+          continue;
+        }
 
-      const value = xlrNode.properties[key];
-      if (value.node.type === "or") {
-        value.node.or.push({
-          type: "ref",
-          ref: "ExpressionRef",
-        });
-        value.node.or.push({
-          type: "ref",
-          ref: "BindingRef",
-        });
-      } else if (isPrimitiveTypeNode(value.node)) {
-        const newUnionType: OrType = {
-          type: "or",
-          description: value.node.description,
-          or: [
-            value.node,
-            {
-              type: "ref",
-              ref: "ExpressionRef",
-            },
-            {
-              type: "ref",
-              ref: "BindingRef",
-            },
-          ],
-        };
-        value.node = newUnionType;
+        const value = xlrNode.properties[key];
+        if (value.node.type === "or") {
+          value.node.or.push({
+            type: "ref",
+            ref: "ExpressionRef",
+          });
+          value.node.or.push({
+            type: "ref",
+            ref: "BindingRef",
+          });
+        } else if (isPrimitiveTypeNode(value.node)) {
+          const newUnionType: OrType = {
+            type: "or",
+            description: value.node.description,
+            or: [
+              value.node,
+              {
+                type: "ref",
+                ref: "ExpressionRef",
+              },
+              {
+                type: "ref",
+                ref: "BindingRef",
+              },
+            ],
+          };
+          value.node = newUnionType;
+        }
       }
-    }
 
-    return xlrNode;
-  })(node, capability);
+      return xlrNode;
+    }
+  )(node, capability);
 };
 
 /**