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

package/src/parser/types.ts

@@ -0,0 +1,314 @@
+// https://github.com/microsoft/vscode-json-languageservice/blob/master/src/jsonLanguageTypes.ts
+import type { Node } from "jsonc-parser";
+
+export type ASTNode =
+  | StringASTNode
+  | NumberASTNode
+  | BooleanASTNode
+  | ArrayASTNode
+  | NullASTNode
+  | PropertyASTNode
+  | ObjectASTNode
+  | AssetASTNode
+  | ViewASTNode
+  | ContentASTNode
+  | NavigationASTNode
+  | FlowASTNode
+  | EmptyASTNode
+  | FlowStateASTNode;
+
+export interface BaseASTNode<T extends string> {
+  /** The base type of the node */
+  readonly type: T;
+
+  /** an optional parent */
+  readonly parent?: ASTNode;
+
+  /** the underlying json node */
+  readonly jsonNode: Node;
+
+  /** any children of the node */
+  readonly children?: ASTNode[];
+}
+
+// Base JSON types
+export interface StringASTNode extends BaseASTNode<"string"> {
+  /** the raw value */
+  readonly value: string;
+}
+
+export interface NumberASTNode extends BaseASTNode<"number"> {
+  /** the raw value */
+  readonly value: number;
+}
+
+export interface BooleanASTNode extends BaseASTNode<"boolean"> {
+  /** the raw value */
+  readonly value: boolean;
+}
+
+export interface ArrayASTNode extends BaseASTNode<"array"> {
+  /** the array items */
+  readonly children: Array<ASTNode>;
+}
+
+export interface NullASTNode extends BaseASTNode<"null"> {
+  /** the raw value */
+  readonly value: null;
+}
+
+export interface EmptyASTNode extends BaseASTNode<"empty"> {
+  /** the raw value */
+  readonly value: undefined;
+}
+
+export interface PropertyASTNode<
+  T extends ASTNode = ASTNode,
+> extends BaseASTNode<"property"> {
+  /** the key of the property */
+  readonly keyNode: StringASTNode;
+
+  /** the value of the property */
+  readonly valueNode?: T;
+}
+
+// Object like things
+export interface ObjectASTNode<
+  T extends string = "object",
+> extends BaseASTNode<T> {
+  /** an array of properties of this object */
+  properties: Array<PropertyASTNode>;
+}
+
+// Player Semantic Nodes
+export interface AssetASTNode extends ObjectASTNode<"asset"> {
+  /** The id property for this asset */
+  readonly id?: PropertyASTNode<StringASTNode>;
+
+  /** The type property for this asset */
+  readonly assetType?: PropertyASTNode<StringASTNode>;
+}
+
+export interface ViewASTNode extends ObjectASTNode<"view"> {
+  /** the id property for this view */
+  readonly id?: PropertyASTNode<StringASTNode>;
+
+  /** the type of the view */
+  readonly viewType?: PropertyASTNode<StringASTNode>;
+}
+
+export interface ContentASTNode extends ObjectASTNode<"content"> {
+  /** the views prop of the flow */
+  readonly views?: PropertyASTNode<ArrayASTNode>;
+
+  /** the nav prop of the flow */
+  readonly navigation?: PropertyASTNode<NavigationASTNode>;
+}
+
+export interface NavigationASTNode extends ObjectASTNode<"navigation"> {
+  /** the begin prop of the navigation node */
+  readonly begin?: PropertyASTNode;
+
+  /** the flows of the navigation node */
+  readonly flows: Array<PropertyASTNode<FlowASTNode>>;
+}
+
+export interface FlowASTNode extends ObjectASTNode<"flow"> {
+  /** the start prop of the node */
+  readonly start?: PropertyASTNode<StringASTNode>;
+
+  /** the defined states */
+  readonly states: Array<PropertyASTNode<FlowStateASTNode>>;
+}
+
+export interface FlowStateASTNode extends ObjectASTNode<"state"> {
+  /** the type of the flow state */
+  readonly stateType?: PropertyASTNode<StringASTNode>;
+}
+
+/** The base class for any node implementation */
+export abstract class ASTNodeImpl {
+  public readonly parent: ASTNode | undefined;
+  public readonly jsonNode: Node;
+
+  constructor(jsonNode: Node, parent: ASTNode | undefined) {
+    this.jsonNode = jsonNode;
+    this.parent = parent;
+  }
+}
+
+/** An implementation of a string node */
+export class StringASTNodeImpl extends ASTNodeImpl implements StringASTNode {
+  public type = "string" as const;
+  public value: string;
+
+  constructor(jsonNode: Node, parent?: ASTNode) {
+    super(jsonNode, parent);
+    this.value = jsonNode.value;
+  }
+}
+
+/** An implementation of the number node */
+export class NumberASTNodeImpl extends ASTNodeImpl implements NumberASTNode {
+  public type = "number" as const;
+  public value: number;
+
+  constructor(jsonNode: Node, parent?: ASTNode) {
+    super(jsonNode, parent);
+    this.value = jsonNode.value;
+  }
+}
+
+/** An implementation of a boolean node */
+export class BooleanASTNodeImpl extends ASTNodeImpl implements BooleanASTNode {
+  public type = "boolean" as const;
+  public value: boolean;
+
+  constructor(jsonNode: Node, parent?: ASTNode) {
+    super(jsonNode, parent);
+    this.value = jsonNode.value;
+  }
+}
+
+/** An implementation of a null node */
+export class NullASTNodeImpl extends ASTNodeImpl implements NullASTNode {
+  public type = "null" as const;
+  public value = null;
+}
+
+/** An implementation of a property node */
+export class PropertyASTNodeImpl
+  extends ASTNodeImpl
+  implements PropertyASTNode
+{
+  public type = "property" as const;
+  public keyNode: StringASTNode;
+  public valueNode?: ASTNode;
+
+  constructor(
+    jsonNode: Node,
+    parent: ASTNode | undefined,
+    keyNode: StringASTNode,
+  ) {
+    super(jsonNode, parent);
+    this.keyNode = keyNode;
+  }
+
+  public get children() {
+    return this.valueNode ? [this.keyNode, this.valueNode] : [this.keyNode];
+  }
+}
+
+/** An implementation of a view node */
+export class ViewASTNodeImpl extends ASTNodeImpl implements ViewASTNode {
+  public type = "view" as const;
+  public properties: PropertyASTNode[] = [];
+  public id?: PropertyASTNode<StringASTNode> = undefined;
+  public viewType?: PropertyASTNode<StringASTNode> = undefined;
+
+  public get children() {
+    return this.properties;
+  }
+}
+
+/** An implementation of a top flow node */
+export class ContentASTNodeImpl extends ASTNodeImpl implements ContentASTNode {
+  public type = "content" as const;
+  public properties: PropertyASTNode[] = [];
+  public views?: PropertyASTNode<ArrayASTNode> = undefined;
+  public navigation?: PropertyASTNode<NavigationASTNode> = undefined;
+
+  public get children() {
+    return this.properties;
+  }
+}
+
+/** An implementation of a navigation node */
+export class NavigationASTNodeImpl
+  extends ASTNodeImpl
+  implements NavigationASTNode
+{
+  public type = "navigation" as const;
+  public properties: PropertyASTNode[] = [];
+  public begin?: PropertyASTNode<StringASTNode> = undefined;
+  public flows: Array<PropertyASTNode<FlowASTNode>> = [];
+
+  public get children() {
+    return this.properties;
+  }
+}
+
+/** An implementation of a flow node */
+export class FlowASTNodeImpl extends ASTNodeImpl implements FlowASTNode {
+  public type = "flow" as const;
+  public properties: PropertyASTNode[] = [];
+  public start?: PropertyASTNode<StringASTNode> = undefined;
+  public states: Array<PropertyASTNode<FlowStateASTNode>> = [];
+
+  public get children() {
+    return this.properties;
+  }
+}
+
+/** An implementation of a flow-state node */
+export class FlowStateASTNodeImpl
+  extends ASTNodeImpl
+  implements FlowStateASTNode
+{
+  public type = "state" as const;
+  public properties: PropertyASTNode[] = [];
+  public stateType?: PropertyASTNode<StringASTNode> = undefined;
+
+  public get children() {
+    return this.properties;
+  }
+}
+
+/** An implementation of an asset node */
+export class AssetASTNodeImpl extends ASTNodeImpl implements AssetASTNode {
+  public type = "asset" as const;
+  public properties: PropertyASTNode[] = [];
+  public id?: PropertyASTNode<StringASTNode> = undefined;
+  public assetType?: PropertyASTNode<StringASTNode> = undefined;
+
+  public get children() {
+    return this.properties;
+  }
+}
+
+/** An implementation of a array node */
+export class ArrayASTNodeImpl extends ASTNodeImpl implements ArrayASTNode {
+  public type = "array" as const;
+  public items: ASTNode[] = [];
+
+  public get children() {
+    return this.items;
+  }
+}
+
+/** An implementation of an object node */
+export class ObjectASTNodeImpl extends ASTNodeImpl implements ObjectASTNode {
+  public type = "object" as const;
+  public properties: PropertyASTNode[] = [];
+
+  public get children() {
+    return this.properties;
+  }
+}
+
+// Edits
+
+export type NodeEdit = ReplaceEdit;
+
+export interface BaseNodeEdit<T extends string> {
+  /** The type of node edit */
+  type: T;
+
+  /** the node to edit */
+  node: ASTNode;
+}
+
+export interface ReplaceEdit extends BaseNodeEdit<"replace"> {
+  /** the new value to replace with */
+  value: any;
+}

package/src/parser/utils.ts

@@ -0,0 +1,94 @@
+import type {
+  ASTNode,
+  PropertyASTNode,
+  StringASTNode,
+  ViewASTNode,
+  ContentASTNode,
+  FlowStateASTNode,
+  ObjectASTNode,
+  FlowASTNode,
+  NavigationASTNode,
+  AssetASTNode,
+} from "./types";
+
+/** check if the node is a property */
+export function isPropertyNode(node?: ASTNode): node is PropertyASTNode {
+  return node?.type === "property";
+}
+
+/** check if the node is an object ast */
+export function isObjectNode(node?: ASTNode): node is ObjectASTNode {
+  return node?.type === "object";
+}
+
+/** check if the node is a key */
+export function isKeyNode(node?: ASTNode): node is StringASTNode {
+  return isPropertyNode(node?.parent) && node?.parent.keyNode === node;
+}
+
+/** check if the node is a value */
+export function isValueNode(node?: ASTNode): boolean {
+  return isPropertyNode(node?.parent) && node?.parent.valueNode === node;
+}
+
+/** check if the node is a view */
+export function isViewNode(node?: ASTNode): node is ViewASTNode {
+  return node?.type === "view";
+}
+
+/** check if the node is a state */
+export function isStateNode(node?: ASTNode): node is FlowStateASTNode {
+  return node?.type === "state";
+}
+
+/** check if the node is a flow */
+export function isFlowNode(node?: ASTNode): node is FlowASTNode {
+  return node?.type === "flow";
+}
+
+/** check if the node is a nav */
+export function isNavigationNode(node?: ASTNode): node is NavigationASTNode {
+  return node?.type === "navigation";
+}
+
+/** get the value for a given key in the object */
+export function getValForKey<T extends ObjectASTNode<any>>(
+  node: T,
+  key: string,
+): any {
+  const prop = node.properties.find((k) => k.keyNode.value === key);
+  return prop?.valueNode?.jsonNode.value;
+}
+
+/** get the key for the given value node */
+export function getPropForValNode(node?: ASTNode): string | undefined {
+  if (isValueNode(node) && isPropertyNode(node?.parent)) {
+    return node?.parent.keyNode.value;
+  }
+}
+
+/** find the view node */
+export function getViewNode(
+  node: ASTNode,
+): ViewASTNode | AssetASTNode | undefined {
+  if (node.parent) {
+    if (node.parent.type === "view") {
+      return node.parent;
+    }
+
+    return getViewNode(node.parent);
+  }
+
+  if (node.type === "asset") {
+    return node;
+  }
+}
+
+/** traverse up until we find the root content node */
+export function getContentNode(node: ASTNode): ContentASTNode | undefined {
+  if (node.type === "content") {
+    return node;
+  }
+
+  return node.parent ? getContentNode(node.parent) : undefined;
+}

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

@@ -0,0 +1,112 @@
+import { test, expect, describe, beforeEach } from "vitest";
+import {
+  ReferenceAssetsWebPluginManifest,
+  Types,
+} from "@player-lang/static-xlrs";
+import { PlayerLanguageService } from "../..";
+import { toTextDocument } from "../../utils";
+
+describe("asset-wrapper-array-plugin", () => {
+  let service: PlayerLanguageService;
+
+  beforeEach(async () => {
+    service = new PlayerLanguageService();
+    await service.setAssetTypesFromModule([
+      Types,
+      ReferenceAssetsWebPluginManifest,
+    ]);
+  });
+
+  test("finds arrays that should be asset wrappers", async () => {
+    const textDocument = toTextDocument(
+      JSON.stringify(
+        {
+          id: "foo",
+          navigation: {
+            BEGIN: "FLOW_1",
+            FLOW_1: {
+              startState: "VIEW_1",
+              VIEW_1: {
+                state_type: "VIEW",
+                ref: "bar",
+                transitions: {},
+              },
+            },
+          },
+          views: [
+            {
+              id: "bar",
+              type: "info",
+              primaryInfo: [
+                {
+                  id: "asset-1",
+                  type: "text",
+                  value: "Foo",
+                },
+              ],
+            },
+          ],
+        },
+        null,
+        2,
+      ),
+    );
+
+    const diags = await service.validateTextDocument(textDocument);
+
+    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.",
+      ]
+    `);
+
+    expect(diags).toMatchInlineSnapshot(`
+      [
+        {
+          "message": "View Validation Error - value: Does not match any of the expected types for type: 'AssetWrapperOrSwitch'",
+          "range": {
+            "end": {
+              "character": 7,
+              "line": 23,
+            },
+            "start": {
+              "character": 21,
+              "line": 17,
+            },
+          },
+          "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": {
+            "end": {
+              "character": 19,
+              "line": 17,
+            },
+            "start": {
+              "character": 6,
+              "line": 17,
+            },
+          },
+          "severity": 1,
+        },
+      ]
+    `);
+  });
+});

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

@@ -0,0 +1,62 @@
+import { test, expect, describe, beforeEach } from "vitest";
+import { Position } from "vscode-languageserver-types";
+import {
+  ReferenceAssetsWebPluginManifest,
+  Types,
+} from "@player-lang/static-xlrs";
+import { PlayerLanguageService } from "../..";
+import { toTextDocument } from "../../utils";
+
+describe("binding-plugin", () => {
+  let service: PlayerLanguageService;
+
+  beforeEach(async () => {
+    service = new PlayerLanguageService();
+    await service.setAssetTypesFromModule([
+      Types,
+      ReferenceAssetsWebPluginManifest,
+    ]);
+  });
+
+  test("auto completes bindings", async () => {
+    const testDocument = toTextDocument(
+      JSON.stringify(
+        {
+          views: [
+            {
+              id: "bar",
+              type: "input",
+              binding: "",
+            },
+          ],
+          schema: {
+            ROOT: {
+              foo: {
+                type: "FooType",
+              },
+            },
+            FooType: {
+              bar: {
+                type: "StringType",
+              },
+            },
+          },
+        },
+        null,
+        2,
+      ),
+    );
+    const completions = await service.getCompletionsAtPosition(
+      testDocument,
+      Position.create(5, 18),
+    );
+
+    expect(completions.items).toHaveLength(2);
+    expect(completions.items.map((c) => c.label)).toMatchInlineSnapshot(`
+      [
+        "foo",
+        "foo.bar",
+      ]
+    `);
+  });
+});