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

package/src/plugins/xlr-plugin.ts

@@ -0,0 +1,371 @@
+import type { NodeType } from "@xlr-lib/xlr";
+import type { ValidationMessage } from "@xlr-lib/xlr-sdk";
+import { ValidationSeverity, XLRSDK } from "@xlr-lib/xlr-sdk";
+import type { CompletionItem } from "vscode-languageserver-types";
+import {
+  CompletionItemKind,
+  DiagnosticSeverity,
+  MarkupKind,
+} from "vscode-languageserver-types";
+import type { Node } from "jsonc-parser";
+import type {
+  ASTVisitor,
+  PlayerLanguageService,
+  PlayerLanguageServicePlugin,
+  ValidationContext,
+} from "..";
+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];
+
+  while (children.length > 0) {
+    const child = children.pop() as ASTNode;
+    if (child.jsonNode === nodeToFind) {
+      return child;
+    }
+
+    if (child.children) {
+      children.push(...child.children);
+    }
+  }
+
+  // if the node can't be found return the original
+  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
+ */
+function createValidationVisitor(
+  ctx: ValidationContext,
+  sdk: XLRSDK,
+): ASTVisitor {
+  const nodesWithErrors = new Set<Node>();
+
+  // TODO cache nodes for LSP usecase. Need to examine which nodes can be cached and how to cache complex objects
+  return {
+    AssetNode: (assetNode) => {
+      // Try and find custom asset but fall back on just validating if its an valid asset if its not found.
+      let expectedType = assetNode.assetType?.valueNode?.value as string;
+
+      if (!sdk.hasType(expectedType)) {
+        ctx.addViolation({
+          node: assetNode,
+          message: `Warning - Asset Type ${assetNode.assetType?.valueNode?.value} was not loaded into Validator definitions`,
+          severity: DiagnosticSeverity.Error,
+        });
+        expectedType = "Asset";
+      }
+
+      const validationIssues = sdk.validateByName(
+        expectedType,
+        assetNode.jsonNode,
+      );
+      validationIssues.forEach((issue) => {
+        if (!(nodesWithErrors.has(issue.node) && isError(issue))) {
+          ctx.addViolation({
+            node: findErrorNode(assetNode, issue.node),
+            message: isError(issue)
+              ? `Asset Validation Error - ${issue.type}: ${issue.message}`
+              : issue.message,
+            severity: translateSeverity(issue.severity),
+          });
+          if (isError(issue)) {
+            nodesWithErrors.add(issue.node);
+          }
+        }
+      });
+    },
+    ViewNode: (viewNode) => {
+      let expectedType = viewNode.viewType?.valueNode?.value as string;
+
+      if (!sdk.hasType(expectedType)) {
+        ctx.addViolation({
+          node: viewNode,
+          message: `Warning - View Type ${viewNode.viewType?.valueNode?.value} was not loaded into Validator definitions`,
+          severity: DiagnosticSeverity.Error,
+        });
+        expectedType = "View";
+      }
+
+      const validationIssues = sdk.validateByName(
+        expectedType,
+        viewNode.jsonNode,
+      );
+      validationIssues.forEach((issue) => {
+        if (!(nodesWithErrors.has(issue.node) && isError(issue))) {
+          ctx.addViolation({
+            node: findErrorNode(viewNode, issue.node),
+            message: isError(issue)
+              ? `View Validation Error - ${issue.type}: ${issue.message}`
+              : issue.message,
+            severity: translateSeverity(issue.severity),
+          });
+          if (isError(issue)) {
+            nodesWithErrors.add(issue.node);
+          }
+        }
+      });
+    },
+    ContentNode: (contentNode) => {
+      const flowType = sdk.getType("Flow");
+
+      if (!flowType) {
+        throw new Error(
+          "Flow is not a registered type, can't validate content. Did you load a version of the base Player types?",
+        );
+      }
+
+      /**
+       * Since the `views.validation` property contains a runtime conditional that is validated anyways when we get to
+       * the ViewNode, replace the reference to `View` with a basic `Asset` instead of trying to solve the generic
+       * for every view present
+       */
+
+      const assetType = sdk.getType("Asset");
+      if (!assetType) {
+        throw new Error(
+          "Asset is not a registered type, can't validate content. Did you load a version of the base Player types?",
+        );
+      }
+
+      if (
+        flowType.type === "object" &&
+        flowType.properties.views?.node.type === "array"
+      ) {
+        flowType.properties.views.node.elementType = assetType;
+      }
+
+      const validationIssues = sdk.validateByType(
+        flowType,
+        contentNode.jsonNode,
+      );
+
+      validationIssues.forEach((issue) => {
+        if (!nodesWithErrors.has(issue.node) || issue.type === "missing") {
+          nodesWithErrors.add(issue.node);
+          ctx.addViolation({
+            node: findErrorNode(contentNode, issue.node),
+            message: `Content Validation Error - ${issue.type}: ${issue.message}`,
+            severity: DiagnosticSeverity.Error,
+          });
+        }
+      });
+    },
+    NavigationNode: (navigationNode) => {
+      const expectedType = "Navigation";
+      const validationIssues = sdk.validateByName(
+        expectedType,
+        navigationNode.jsonNode,
+      );
+      validationIssues.forEach((issue) => {
+        if (!nodesWithErrors.has(issue.node) || issue.type === "missing") {
+          nodesWithErrors.add(issue.node);
+          ctx.addViolation({
+            node: findErrorNode(navigationNode, issue.node),
+            message: `Navigation Validation Error - ${issue.type}: ${issue.message}`,
+            severity: DiagnosticSeverity.Error,
+          });
+        }
+      });
+    },
+    FlowNode: (flowNode) => {
+      const expectedType = "NavigationFlow";
+      const validationIssues = sdk.validateByName(
+        expectedType,
+        flowNode.jsonNode,
+      );
+      validationIssues.forEach((issue) => {
+        if (!nodesWithErrors.has(issue.node) || issue.type === "missing") {
+          nodesWithErrors.add(issue.node);
+          ctx.addViolation({
+            node: findErrorNode(flowNode, issue.node),
+            message: `Navigation Flow Validation Error - ${issue.type}: ${issue.message}`,
+            severity: DiagnosticSeverity.Error,
+          });
+        }
+      });
+    },
+    FlowStateNode: (flowStateNode) => {
+      const flowxlr = mapFlowStateToType(
+        flowStateNode.stateType?.valueNode?.value,
+      );
+
+      if (flowxlr) {
+        const validationIssues = sdk.validateByName(
+          flowxlr,
+          flowStateNode.jsonNode,
+        );
+        validationIssues.forEach((issue) => {
+          if (!nodesWithErrors.has(issue.node) || issue.type === "missing") {
+            nodesWithErrors.add(issue.node);
+            ctx.addViolation({
+              node: findErrorNode(flowStateNode, issue.node),
+              message: `Navigation Node Validation Error - ${issue.type}: ${issue.message}`,
+              severity: DiagnosticSeverity.Error,
+            });
+          }
+        });
+      } else {
+        ctx.addViolation({
+          node: flowStateNode,
+          message:
+            "Unknown Flow Type, valid options are: VIEW, END, ACTION, EXTERNAL, FLOW",
+          severity: DiagnosticSeverity.Error,
+        });
+      }
+    },
+  };
+}
+
+/** Gets object completions */
+function getObjectCompletions(
+  authoredNode: ASTNode,
+  potentialTypes: Array<NodeType>,
+) {
+  const completions: Array<CompletionItem> = [];
+
+  const presentKeys = new Set();
+  if ((authoredNode as ObjectASTNode).properties) {
+    (authoredNode as ObjectASTNode).properties.forEach((propertyNode) =>
+      presentKeys.add(propertyNode.keyNode.value),
+    );
+  }
+
+  potentialTypes.forEach((node) => {
+    if (node.type === "object") {
+      Object.keys(node.properties).forEach((prop) => {
+        if (!presentKeys.has(prop)) {
+          completions.push({
+            label: prop,
+            documentation:
+              node.properties[prop].node.description ??
+              node.properties[prop].node.title,
+            kind: CompletionItemKind.Property,
+          });
+        }
+      });
+    } else if (node.type === "and") {
+      completions.push(...getObjectCompletions(authoredNode, node.and));
+    } else if (node.type === "or") {
+      completions.push(...getObjectCompletions(authoredNode, node.or));
+    }
+  });
+
+  return completions;
+}
+
+/** get value completions */
+function getPropertyCompletions(
+  propertyName: string,
+  potentialTypes: Array<NodeType>,
+) {
+  const completions: Array<CompletionItem> = [];
+  potentialTypes.forEach((nodeType) => {
+    if (nodeType.type === "object") {
+      const propertyNode = nodeType.properties[propertyName]?.node;
+      if (
+        propertyNode &&
+        propertyNode.type === "string" &&
+        propertyNode.const
+      ) {
+        completions.push({
+          label: propertyNode.const,
+          kind: CompletionItemKind.Value,
+        });
+      }
+    }
+  });
+
+  return completions;
+}
+
+/** returns completions for object properties */
+function complete(
+  ctx: EnhancedDocumentContextWithPosition,
+): Array<CompletionItem> {
+  if (ctx.XLR?.nearestObjects) {
+    if (ctx.node.type === "string" && ctx.node?.parent?.type === "property") {
+      return getPropertyCompletions(
+        ctx.node.parent.keyNode.value,
+        ctx.XLR.nearestObjects,
+      );
+    }
+
+    return getObjectCompletions(ctx.node, ctx.XLR.nearestObjects);
+  }
+
+  return [];
+}
+
+/** gets hover docs */
+function hover(ctx: EnhancedDocumentContextWithPosition) {
+  if (ctx.XLR && ctx.node.type === "string") {
+    const docStrings: Array<string> = [];
+    const prop = ctx.node.value;
+
+    ctx.XLR.nearestObjects.forEach((typeNode) => {
+      const docString =
+        typeNode.properties[prop]?.node?.description ??
+        typeNode.properties[prop]?.node?.title ??
+        undefined;
+      if (docString) {
+        docStrings.push(docString);
+      }
+    });
+
+    if (docStrings.length > 1) {
+      return {
+        contents: {
+          kind: MarkupKind.PlainText,
+          value:
+            "Docs unavailable - More than one type could exist at this location",
+        },
+      };
+    }
+
+    return {
+      contents: {
+        kind: MarkupKind.PlainText,
+        value: docStrings[0] ?? "Error getting docs",
+      },
+    };
+  }
+}
+
+/** The plugin to enable duplicate id checking/fixing */
+export class XLRPlugin implements PlayerLanguageServicePlugin {
+  name = "xlr-plugin";
+
+  apply(service: PlayerLanguageService): void {
+    service.hooks.validate.tap(this.name, async (ctx, validation) => {
+      validation.useASTVisitor(
+        createValidationVisitor(validation, service.XLRService.XLRSDK),
+      );
+    });
+    service.hooks.complete.tap(this.name, async (ctx, completion) => {
+      complete(ctx).map((i) => completion.addCompletionItem(i));
+    });
+    service.hooks.hover.tap(this.name, (ctx) => {
+      return hover(ctx);
+    });
+  }
+}

package/src/types.ts

@@ -0,0 +1,119 @@
+import type { TextDocument } from "vscode-languageserver-textdocument";
+import type {
+  Position,
+  DiagnosticSeverity,
+  Diagnostic,
+  CompletionItem,
+} from "vscode-languageserver-types";
+import type {
+  ASTNode,
+  PlayerContent,
+  StringASTNode,
+  NumberASTNode,
+  ArrayASTNode,
+  BooleanASTNode,
+  PropertyASTNode,
+  ObjectASTNode,
+  ViewASTNode,
+  ContentASTNode,
+  NullASTNode,
+  AssetASTNode,
+  FlowStateASTNode,
+  NavigationASTNode,
+  FlowASTNode,
+  NodeEdit,
+  EmptyASTNode,
+} from "./parser";
+import type { XLRContext } from "./xlr";
+
+export type LogFn = (msg: string) => void;
+export const LOG_TYPES = ["debug", "info", "warn", "error"] as const;
+export type LogType = (typeof LOG_TYPES)[number];
+export type Logger = Record<LogType, LogFn>;
+
+export interface DocumentContext {
+  /** A logger to log messages */
+  log: Logger;
+
+  /** the underlying text document */
+  document: TextDocument;
+
+  /** the json parsed text document */
+  PlayerContent: PlayerContent;
+}
+
+export interface DocumentContextWithPosition extends DocumentContext {
+  /** the position we care about */
+  position: Position;
+
+  /** the node at that position */
+  node: ASTNode;
+}
+
+export interface EnhancedDocumentContextWithPosition extends DocumentContextWithPosition {
+  /** the XLRs context */
+  XLR?: XLRContext;
+}
+
+export type ASTVisitorFn<T extends ASTNode> = (node: T) => void;
+
+export interface ASTVisitor {
+  /** a string node visitor */
+  StringNode?: ASTVisitorFn<StringASTNode>;
+  /** a number node visitor */
+  NumberNode?: ASTVisitorFn<NumberASTNode>;
+  /** an boolean node visitor */
+  BooleanNode?: ASTVisitorFn<BooleanASTNode>;
+  /** an array node visitor */
+  ArrayNode?: ASTVisitorFn<ArrayASTNode>;
+  /** a null node visitor */
+  NullNode?: ASTVisitorFn<NullASTNode>;
+  /** an empty node visitor */
+  EmptyNode?: ASTVisitorFn<EmptyASTNode>;
+  /** a property node visitor */
+  PropertyNode?: ASTVisitorFn<PropertyASTNode>;
+  /** an object node visitor */
+  ObjectNode?: ASTVisitorFn<ObjectASTNode>;
+  /** an asset node visitor */
+  AssetNode?: ASTVisitorFn<AssetASTNode>;
+  /** a view node visitor */
+  ViewNode?: ASTVisitorFn<ViewASTNode>;
+  /** a flow node visitor */
+  ContentNode?: ASTVisitorFn<ContentASTNode>;
+  /** a navigation node visitor */
+  NavigationNode?: ASTVisitorFn<NavigationASTNode>;
+  /** a flow node visitor */
+  FlowNode?: ASTVisitorFn<FlowASTNode>;
+  /** a flow state node visitor */
+  FlowStateNode?: ASTVisitorFn<FlowStateASTNode>;
+}
+
+export interface Violation {
+  /** the node the violation is for */
+  node: ASTNode;
+
+  /** the message to show */
+  message: string;
+
+  /** how much do we care? */
+  severity: DiagnosticSeverity;
+
+  /** A function that can make this good */
+  fix?: () => {
+    /** the edit to apply */
+    edit: NodeEdit;
+
+    /** A name for your fix */
+    name: string;
+  };
+}
+
+export interface ValidationContext {
+  addViolation(violation: Violation): void;
+  addDiagnostic(diagnostic: Diagnostic): void;
+  useASTVisitor(visitor: ASTVisitor): void;
+}
+
+export interface CompletionContext {
+  addCompletionItem(item: CompletionItem): void;
+}

package/src/utils.ts

@@ -0,0 +1,143 @@
+import { Range, Location } from "vscode-languageserver-types";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import detectIndent from "detect-indent";
+import type {
+  ASTNode,
+  PlayerContent,
+  ObjectASTNode,
+  PropertyASTNode,
+} from "./parser";
+import type { ASTVisitor } from "./types";
+
+export const typeToVisitorMap: Record<ASTNode["type"], keyof ASTVisitor> = {
+  string: "StringNode",
+  number: "NumberNode",
+  boolean: "BooleanNode",
+  array: "ArrayNode",
+  null: "NullNode",
+  empty: "EmptyNode",
+  property: "PropertyNode",
+  object: "ObjectNode",
+  asset: "AssetNode",
+  view: "ViewNode",
+  content: "ContentNode",
+  navigation: "NavigationNode",
+  flow: "FlowNode",
+  state: "FlowStateNode",
+};
+
+/** Check to see if the source range contains the target one */
+export function containsRange(source: Range, range: Range): boolean {
+  const { start, end } = range;
+  const { start: srcStart, end: srcEnd } = source;
+
+  return (
+    start.line === srcStart.line &&
+    end.line === srcEnd.line &&
+    start.character >= srcStart.character &&
+    end.character <= srcEnd.character
+  );
+}
+
+/** Create a dummy TextDocument from the given string */
+export function toTextDocument(str: string): TextDocument {
+  return TextDocument.create("foo", "json", 1, str);
+}
+
+/** Check to see if the document successfully parsed into a known root type */
+export function isKnownRootType(document: PlayerContent): boolean {
+  const { type } = document.root;
+
+  return type === "view" || type === "asset" || type === "content";
+}
+
+/** Check to see if the node is the value of an object */
+export function isValueCompletion(node: ASTNode): boolean {
+  return node.parent?.type === "property" && node.parent.valueNode === node;
+}
+
+/** Check to see if the node is the key of an object */
+export function isPropertyCompletion(node: ASTNode): boolean {
+  return node.parent?.type === "property" && node.parent.keyNode === node;
+}
+
+/** Search the object for a property with the given name */
+export function getProperty<T extends ASTNode>(
+  obj: T,
+  name: string,
+): PropertyASTNode | undefined {
+  if ("properties" in obj) {
+    return (obj as ObjectASTNode).properties.find(
+      (p) => p.keyNode.value === name,
+    );
+  }
+}
+
+/** Get the LSP Location of an AST node in a document */
+export function getLSLocationOfNode(
+  document: TextDocument,
+  node: ASTNode,
+): Location {
+  const nodeRange = Range.create(
+    document.positionAt(node.jsonNode.offset),
+    document.positionAt(node.jsonNode.offset + node.jsonNode.length),
+  );
+
+  return Location.create(document.uri, nodeRange);
+}
+
+/** Get the depth of the property */
+function getDepth(node: ASTNode): number {
+  if (!node.parent) {
+    return 0;
+  }
+
+  if (node.type === "property") {
+    return getDepth(node.parent);
+  }
+
+  return 1 + getDepth(node.parent);
+}
+
+/** Format a new node like an existing one (including the indentation) */
+export function formatLikeNode(
+  document: TextDocument,
+  originalNode: ASTNode,
+  replacement: Record<string, unknown>,
+): string {
+  const { indent } = detectIndent(document.getText());
+  const depth = getDepth(originalNode);
+
+  return JSON.stringify(replacement, null, indent)
+    .split("\n")
+    .map((l, index) => (index === 0 ? l : `${indent.repeat(depth)}${l}`))
+    .join("\n");
+}
+
+/** Maps the string identifying the FlowType to the named type */
+export function mapFlowStateToType(
+  flowType: string | undefined,
+): string | undefined {
+  let flowXLR;
+  switch (flowType) {
+    case "VIEW":
+      flowXLR = "NavigationFlowViewState";
+      break;
+    case "END":
+      flowXLR = "NavigationFlowEndState";
+      break;
+    case "ACTION":
+      flowXLR = "NavigationFlowActionState";
+      break;
+    case "EXTERNAL":
+      flowXLR = "NavigationFlowExternalState";
+      break;
+    case "FLOW":
+      flowXLR = "NavigationFlowFlowState";
+      break;
+    default:
+      break;
+  }
+
+  return flowXLR;
+}