@player-lang/json-language-service 0.0.2-next.0

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

@@ -0,0 +1,123 @@
+import type { NodeType } from "@xlr-lib/xlr";
+import { DiagnosticSeverity } from "vscode-languageserver-types";
+import type { PlayerLanguageService, PlayerLanguageServicePlugin } from "..";
+import type { ASTNode, StringASTNode } from "../parser";
+import { getNodeValue } from "../parser";
+import { formatLikeNode } from "../utils";
+
+/** Check if the node is defined within a view */
+const isInView = (node: ASTNode): boolean => {
+  if (node.type === "view") {
+    return true;
+  }
+
+  if (!node.parent) {
+    return false;
+  }
+
+  return isInView(node.parent);
+};
+
+/**
+ * Checks to see if there is an AssetWrapper ref node somewhere at this level
+ *
+ * - @param nodes Array of nodes to check for an AssetWrapper ref
+ */
+const checkTypesForAssetWrapper = (nodes: Array<NodeType>): boolean => {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (node.type === "object" && node.title?.includes("AssetWrapper")) {
+      return true;
+    } else if (node.type === "or") {
+      return checkTypesForAssetWrapper(node.or);
+    } else if (node.type === "and") {
+      return checkTypesForAssetWrapper(node.and);
+    }
+  }
+
+  return false;
+};
+
+/**
+ * Checks to see if the array's parent property is a switch statement
+ */
+const checkSwitchCase = (node: StringASTNode): boolean => {
+  return node.value === "staticSwitch" || node.value === "dynamicSwitch";
+};
+
+/**
+ * Looks for an array where there _should_ be an AssetWrapper
+ */
+export class AssetWrapperArrayPlugin implements PlayerLanguageServicePlugin {
+  name = "asset-wrapper-to-array";
+
+  apply(service: PlayerLanguageService): void {
+    service.hooks.validate.tap(
+      this.name,
+      async (documentInfo, validationContext) => {
+        validationContext.useASTVisitor({
+          ArrayNode: async (arrayNode) => {
+            if (!isInView(arrayNode)) {
+              return;
+            }
+
+            const xlrInfo = service.XLRService.getTypeInfoAtPosition(arrayNode);
+            if (!xlrInfo) return;
+
+            const isAssetWrapper = checkTypesForAssetWrapper(xlrInfo.nodes);
+
+            const parentNode = arrayNode.parent;
+
+            if (parentNode?.type !== "property") {
+              return;
+            }
+
+            const targetLabel = parentNode.keyNode;
+
+            // manual check because switch types have arrays of asset wrappers but don't extend asset wrapper
+            const isSwitchCase = checkSwitchCase(targetLabel);
+
+            if (isAssetWrapper && !isSwitchCase) {
+              // This is an array node that _should_ be an asset wrapper.
+              // Convert it to a collection
+
+              let newAsset = {
+                asset: {
+                  id: "",
+                  type: "collection",
+                  values: getNodeValue(arrayNode),
+                },
+              };
+
+              if (arrayNode.children.length === 1) {
+                newAsset = getNodeValue(arrayNode.children[0]);
+              }
+
+              validationContext.addViolation({
+                node: targetLabel,
+                severity: DiagnosticSeverity.Error,
+                message: `Implicit Array -> "collection" assets is not supported.`,
+                fix: () => {
+                  return {
+                    name: `Convert to ${
+                      arrayNode.children.length > 0 ? "collection" : "asset"
+                    }`,
+                    edit: {
+                      type: "replace",
+                      node: arrayNode,
+                      value: formatLikeNode(
+                        documentInfo.document,
+                        arrayNode,
+                        newAsset,
+                      ),
+                    },
+                  };
+                },
+              });
+            }
+          },
+        });
+      },
+    );
+  }
+}

package/src/plugins/binding-schema-plugin.ts

@@ -0,0 +1,289 @@
+import type { Location } from "vscode-languageserver-types";
+import { CompletionItemKind } from "vscode-languageserver-types";
+import type { NodeType } from "@xlr-lib/xlr";
+import type { PlayerLanguageService, PlayerLanguageServicePlugin } from "..";
+import type {
+  DocumentContext,
+  EnhancedDocumentContextWithPosition,
+} from "../types";
+import { getLSLocationOfNode, getProperty, isValueCompletion } from "../utils";
+import type { PropertyASTNode, StringASTNode } from "../parser";
+import { getContentNode } from "../parser";
+
+interface SchemaInfo {
+  /** mapping of binding to schema path */
+  bindingToSchemaType: Map<
+    string,
+    {
+      /** the binding */
+      binding: string;
+
+      /** the type name */
+      typeName: string;
+
+      /** the name of the key */
+      key: string;
+    }
+  >;
+
+  /** JSON AST mapping of type to the node */
+  typeToNode: Map<
+    string,
+    {
+      /** the type  */
+      type: string;
+
+      /** the json node */
+      typeNode: PropertyASTNode;
+    }
+  >;
+}
+
+/** parse the document for the schema info */
+function getBindingInfo(ctx: DocumentContext): SchemaInfo {
+  const info: SchemaInfo = {
+    bindingToSchemaType: new Map(),
+    typeToNode: new Map(),
+  };
+
+  if (ctx.PlayerContent.root.type !== "content") {
+    return info;
+  }
+
+  const schemaRoot = ctx.PlayerContent.root.properties?.find(
+    (child) => child.keyNode.value === "schema",
+  );
+
+  if (!schemaRoot || schemaRoot.valueNode?.type !== "object") {
+    return info;
+  }
+
+  const schemaTypeQueue: Array<{
+    /** the current path  */
+    currentPath: string;
+
+    /** the next type to visit */
+    typeToVisit: string;
+
+    /** list of visited types (to prevent loops) */
+    visited: Set<string>;
+  }> = [
+    {
+      currentPath: "",
+      typeToVisit: "ROOT",
+      visited: new Set(),
+    },
+  ];
+
+  while (schemaTypeQueue.length > 0) {
+    const next = schemaTypeQueue.shift();
+    if (!next) {
+      break;
+    }
+
+    if (next.visited.has(next.typeToVisit)) {
+      continue;
+    }
+
+    const visited = new Set(...next.visited, next.typeToVisit);
+    const { currentPath, typeToVisit } = next;
+
+    const typeNode = schemaRoot.valueNode.properties.find(
+      (child) => child.keyNode.value === typeToVisit,
+    );
+
+    if (!typeNode || typeNode.valueNode?.type !== "object") {
+      continue;
+    }
+
+    info.typeToNode.set(typeToVisit, { type: typeToVisit, typeNode });
+
+    typeNode.valueNode.properties.forEach((prop) => {
+      // PropName is the path
+      // { type: TYPE } is the next nested type
+
+      const nextPath = [currentPath, prop.keyNode.value].join(
+        currentPath === "" ? "" : ".",
+      );
+
+      info.bindingToSchemaType.set(nextPath, {
+        binding: nextPath,
+        typeName: typeToVisit,
+        key: prop.keyNode.value,
+      });
+
+      if (prop.valueNode?.type === "object") {
+        const nestedTypeName = prop.valueNode.properties.find(
+          (c) => c.keyNode.value === "type",
+        );
+
+        if (nestedTypeName && nestedTypeName.valueNode?.type === "string") {
+          schemaTypeQueue.push({
+            currentPath: nextPath,
+            typeToVisit: nestedTypeName.valueNode.value,
+            visited,
+          });
+        }
+      }
+    });
+  }
+
+  return info;
+}
+
+/**
+ * Checks to see if there is a Binding ref node somewhere at this level
+ *
+ * - @param nodes Array of nodes to check for an AssetWrapper ref
+ */
+const checkTypesForBinding = (nodes: Array<NodeType>): boolean => {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (node.type === "string" && node.name === "Binding") return true;
+    if (node.type === "or") return checkTypesForBinding(node.or);
+    if (node.type === "and") return checkTypesForBinding(node.and);
+  }
+
+  return false;
+};
+
+/** check if the property is of type Binding */
+function isBindingPropertyAssignment(
+  ctx: EnhancedDocumentContextWithPosition,
+): boolean {
+  if (ctx.node.type !== "string" || ctx.node.parent?.type !== "property") {
+    return false;
+  }
+
+  if (checkTypesForBinding(ctx.XLR?.nodes ?? [])) {
+    return true;
+  }
+
+  return false;
+}
+
+/** find where in the document the type def is located */
+function getLocationForBindingTypeDefinition(
+  ctx: EnhancedDocumentContextWithPosition,
+  schemaInfo: SchemaInfo,
+): Location | undefined {
+  if (!isBindingPropertyAssignment(ctx)) {
+    return;
+  }
+
+  const existingBindingValue = (ctx.node as StringASTNode).value;
+  const info = schemaInfo.bindingToSchemaType.get(existingBindingValue);
+
+  if (!info) {
+    return;
+  }
+
+  const nodeLocation = schemaInfo.typeToNode.get(info.typeName);
+
+  if (!nodeLocation || nodeLocation.typeNode.valueNode?.type !== "object") {
+    return;
+  }
+
+  const prop = getProperty(nodeLocation.typeNode.valueNode, info.key);
+
+  if (!prop) {
+    return;
+  }
+
+  return getLSLocationOfNode(ctx.document, prop);
+}
+
+/** find where the schema is for a type */
+function getLocationForSchemaType(
+  ctx: EnhancedDocumentContextWithPosition,
+  schemaInfo: SchemaInfo,
+): Location | undefined {
+  if (isValueCompletion(ctx.node)) {
+    // See if we're the "type" prop of a schema lookup
+
+    if (
+      ctx.node.parent?.type === "property" &&
+      ctx.node.type === "string" &&
+      ctx.node.parent.keyNode.value === "type"
+    ) {
+      const typeName = ctx.node.value;
+      const node = schemaInfo.typeToNode.get(typeName);
+
+      if (!node) {
+        return;
+      }
+
+      const schemaPropNode = getContentNode(ctx.node)?.properties.find(
+        (p) => p.keyNode.value === "schema",
+      );
+
+      if (schemaPropNode?.valueNode?.type !== "object") {
+        return;
+      }
+
+      const schemaTypeNode = schemaPropNode.valueNode.properties.find(
+        (p) => p.keyNode.value === typeName,
+      );
+
+      if (schemaTypeNode !== node.typeNode) {
+        return;
+      }
+
+      return getLSLocationOfNode(ctx.document, node.typeNode);
+    }
+  }
+}
+
+/**
+ *
+ * Adds completions for:
+ * - any `Binding` type from TS
+ * - "type" and "key" for non-defined types
+ *
+ * Adds definitions for:
+ * - any `Binding` reference to the schema def
+ */
+export class SchemaInfoPlugin implements PlayerLanguageServicePlugin {
+  name = "view-node";
+
+  apply(service: PlayerLanguageService): void {
+    let schemaInfo: SchemaInfo | undefined;
+
+    service.hooks.onDocumentUpdate.tap(this.name, (ctx) => {
+      schemaInfo = getBindingInfo(ctx);
+    });
+
+    service.hooks.complete.tap(this.name, async (ctx, completionCtx) => {
+      // Is this a `binding` type
+      if (!isBindingPropertyAssignment(ctx)) {
+        return;
+      }
+
+      const existingBindingValue = (ctx.node as StringASTNode).value;
+
+      const bindings = Array.from(
+        schemaInfo?.bindingToSchemaType.keys() ?? [],
+      ).filter((k) => k.startsWith(existingBindingValue));
+
+      bindings.forEach((b) => {
+        completionCtx.addCompletionItem({
+          kind: CompletionItemKind.Value,
+          label: b.substring(existingBindingValue.length),
+        });
+      });
+
+      // get bindings from schema
+    });
+
+    service.hooks.definition.tap(this.name, (ctx) => {
+      if (!schemaInfo) {
+        return;
+      }
+
+      return (
+        getLocationForSchemaType(ctx, schemaInfo) ||
+        getLocationForBindingTypeDefinition(ctx, schemaInfo)
+      );
+    });
+  }
+}

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

@@ -0,0 +1,158 @@
+import { DiagnosticSeverity } from "vscode-languageserver-types";
+import type { AssetASTNode, ASTNode, ViewASTNode } 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") {
+    return "";
+  }
+
+  const prefix = generateID(node.parent);
+  let current = "";
+
+  if (node.type === "property") {
+    current = node.keyNode.value;
+  } else if (node.type === "asset" && node.assetType?.valueNode?.value) {
+    current = node.assetType.valueNode?.value;
+  }
+
+  return [prefix, current].filter(Boolean).join("-");
+};
+
+/** Create a duplicate id violation for the given node */
+const createViolation = (node: AssetASTNode): Violation | undefined => {
+  const valueNode = node.id?.valueNode;
+
+  if (!valueNode) {
+    return;
+  }
+
+  return {
+    node: valueNode,
+    severity: DiagnosticSeverity.Error,
+    message: `The id "${node.id?.valueNode?.value}" is already in use in this view.`,
+    fix: () => {
+      return {
+        name: "Generate new ID",
+        edit: replaceString(valueNode, `"${generateID(node)}"`),
+      };
+    },
+  };
+};
+
+/** visit each of the assets in a view and check for duplicate ids */
+const createValidationVisitor = (ctx: ValidationContext): ASTVisitor => {
+  const viewInfo = new Map<
+    ViewASTNode | AssetASTNode,
+    Map<
+      string,
+      {
+        /** the original asset node */
+        original: AssetASTNode;
+
+        /** if we've accounted for this node already */
+        handled: boolean;
+      }
+    >
+  >();
+
+  return {
+    AssetNode: (assetNode) => {
+      const view = getViewNode(assetNode);
+      if (!view) {
+        // not sure how you can get here
+        throw new Error(
+          "Asset found but not within a view. Something is wrong",
+        );
+      }
+
+      const assetID = assetNode.id;
+
+      if (!assetID || !assetID.valueNode?.value) {
+        // Can"t check for dupe ids if the asset doesn"t have one
+        return;
+      }
+
+      const id = assetID.valueNode?.value;
+      if (!viewInfo.has(view)) {
+        viewInfo.set(view, new Map());
+      }
+
+      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);
+          if (origViolation) {
+            ctx.addViolation(origViolation);
+          }
+
+          idInfo.handled = true;
+        }
+
+        const assetViolation = createViolation(assetNode);
+        if (assetViolation) {
+          ctx.addViolation(assetViolation);
+        }
+      } else {
+        // not claimed yet so this is the first
+        assetIDMap?.set(id, { original: assetNode, handled: false });
+      }
+    },
+  };
+};
+
+/** The plugin to enable duplicate id checking/fixing */
+export class DuplicateIDPlugin implements PlayerLanguageServicePlugin {
+  name = "duplicate-id";
+
+  apply(service: PlayerLanguageService): void {
+    service.hooks.validate.tap(this.name, async (ctx, validation) => {
+      validation.useASTVisitor(createValidationVisitor(validation));
+    });
+  }
+}

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

@@ -0,0 +1,96 @@
+import { DiagnosticSeverity } from "vscode-languageserver-types";
+import type { PlayerLanguageService, PlayerLanguageServicePlugin } from "..";
+import type { ASTNode, ObjectASTNode } from "../parser";
+import {
+  getNodeValue,
+  isKeyNode,
+  isObjectNode,
+  isPropertyNode,
+} from "../parser";
+import { formatLikeNode } from "../utils";
+
+/** Get the JSON object that the validation targets */
+const getObjectTarget = (node?: ASTNode): ObjectASTNode | undefined => {
+  if (isObjectNode(node)) {
+    return node;
+  }
+
+  if (
+    isKeyNode(node) &&
+    isPropertyNode(node.parent) &&
+    isObjectNode(node.parent.valueNode)
+  ) {
+    return node.parent.valueNode;
+  }
+};
+
+/**
+ * A plugin to help identify and fix the issue of forgetting the "asset" wrapper object
+ */
+export class MissingAssetWrapperPlugin implements PlayerLanguageServicePlugin {
+  name = "missing-asset-wrapper";
+
+  apply(languageService: PlayerLanguageService): void {
+    languageService.hooks.onValidateEnd.tap(
+      this.name,
+      (diagnostics, { addFixableViolation, documentContext }) => {
+        // Just be naive here
+        // If there's an error for "expected asset" + an unexpected `id` and `type`, replace that with our own
+
+        let filteredDiags = diagnostics;
+
+        const expectedAssetDiags = diagnostics.filter(
+          (d) =>
+            d.message.includes(
+              `Does not match any of the expected types for type: 'AssetWrapperOrSwitch'`,
+            ) || d.message.startsWith("Expected property: asset"),
+        );
+
+        expectedAssetDiags.forEach((d) => {
+          const originalNode = documentContext.PlayerContent.getNodeFromOffset(
+            documentContext.document.offsetAt(d.range.start),
+          );
+
+          const objectNode = getObjectTarget(originalNode);
+
+          if (objectNode && originalNode) {
+            // This "expected property" diag is for the key of a property, where the value is the stubbed out asset
+            // Check for diags for keys in that nested object
+
+            // Now group the other diagnostics that are for unexpected props underneath that object
+            // We"ll suppress these for now since they are bound to be wrong until they"re wrapped in an asset
+            const associatedDiags = filteredDiags.filter((nestedDiag) => {
+              const diagNode = documentContext.PlayerContent.getNodeFromOffset(
+                documentContext.document.offsetAt(nestedDiag.range.start),
+              );
+
+              return objectNode.properties.some((p) => p.keyNode === diagNode);
+            });
+
+            addFixableViolation(d, {
+              node: originalNode,
+              message: d.message,
+              severity: d.severity ?? DiagnosticSeverity.Error,
+              fix: () => ({
+                name: `Wrap in "asset"`,
+                edit: {
+                  type: "replace",
+                  node: objectNode,
+                  value: formatLikeNode(documentContext.document, objectNode, {
+                    asset: getNodeValue(objectNode),
+                  }),
+                },
+              }),
+            });
+
+            filteredDiags = filteredDiags.filter(
+              (filteredD) => !associatedDiags.includes(filteredD),
+            );
+          }
+        });
+
+        return filteredDiags;
+      },
+    );
+  }
+}