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

package/src/xlr/service.ts

@@ -0,0 +1,190 @@
+import { XLRSDK } from "@xlr-lib/xlr-sdk";
+import type { ArrayType, NodeType, ObjectType } from "@xlr-lib/xlr";
+import type { ASTNode } from "../parser";
+import { mapFlowStateToType } from "../utils";
+import { PlayerXLRRegistry } from "./registry";
+
+export interface XLRContext {
+  /** The name of the XLR at the provided position */
+  name: string;
+
+  /** The position(s) in the XLR at the specified node */
+  nodes: Array<NodeType>;
+
+  /** The nearest objects(s) to the specified node */
+  nearestObjects: Array<ObjectType>;
+}
+
+/**
+ * XLRs Manager for
+ */
+export class XLRService {
+  private baseTypes = [
+    "asset",
+    "view",
+    "flow",
+    "content",
+    "navigation",
+    "state",
+  ];
+
+  public XLRSDK: XLRSDK;
+
+  constructor() {
+    this.XLRSDK = new XLRSDK(new PlayerXLRRegistry());
+  }
+
+  private walker(
+    n: ASTNode,
+    path: ASTNode[],
+  ):
+    | {
+        /** name of type */
+        name: string;
+
+        /** path to get there from n */
+        path: ASTNode[];
+      }
+    | undefined {
+    if (this.baseTypes.indexOf(n.type) > -1) {
+      if (n.type === "asset") {
+        const name = this.XLRSDK.hasType(n.assetType?.valueNode?.value ?? "")
+          ? (n.assetType?.valueNode?.value as string)
+          : "Asset";
+        return {
+          name,
+          path,
+        };
+      }
+
+      if (n.type === "view") {
+        const name = this.XLRSDK.hasType(n.viewType?.valueNode?.value ?? "")
+          ? (n.viewType?.valueNode?.value as string)
+          : "View";
+        return { name, path };
+      }
+
+      if (n.type === "state") {
+        if (n.stateType?.valueNode?.value) {
+          const flowStateType = mapFlowStateToType(
+            n.stateType?.valueNode?.value,
+          );
+          if (flowStateType) {
+            return { name: flowStateType, path };
+          }
+        }
+      }
+
+      if (n.type === "content") {
+        return { name: "Flow", path };
+      }
+
+      if (n.type === "flow") {
+        return { name: "NavigationFlow", path };
+      }
+
+      if (n.type === "navigation") {
+        return { name: "Navigation", path };
+      }
+    }
+
+    if (n.parent) {
+      path.push(n.parent);
+      return this.walker(n.parent, path);
+    }
+
+    return undefined;
+  }
+
+  public getTypeInfoAtPosition(
+    node: ASTNode | undefined,
+  ): XLRContext | undefined {
+    if (!node) return;
+
+    const pointer = node;
+    const xlrInfo = this.walker(pointer, []);
+
+    // bail if we can"t figure out the type or don"t have it
+    if (!xlrInfo) return;
+
+    const activeNode = this.XLRSDK.getType(xlrInfo.name);
+    if (!activeNode) return;
+
+    let nearestObjectTypes = [activeNode as ObjectType];
+    let pointers = [];
+
+    if (activeNode.type === "and") {
+      pointers = activeNode.and;
+    } else if (activeNode.type === "or") {
+      pointers = activeNode.or;
+    } else {
+      pointers = [activeNode];
+    }
+
+    for (const pathSegment of xlrInfo.path.reverse()) {
+      const newPointers: NodeType[] = [];
+
+      for (let nodePointer of pointers) {
+        let newNode;
+
+        if (nodePointer.type === "ref") {
+          if (this.XLRSDK.hasType(nodePointer.ref)) {
+            nodePointer = this.XLRSDK.getType(nodePointer.ref) as ObjectType;
+          } else {
+            continue;
+          }
+        }
+
+        if (pathSegment.type === "property" && nodePointer.type === "object") {
+          if (nodePointer?.properties[pathSegment.keyNode.value]) {
+            newNode = nodePointer?.properties[pathSegment.keyNode.value]?.node;
+          } else if (nodePointer?.additionalProperties) {
+            // search through additional properties types
+            const adNode = nodePointer?.additionalProperties;
+            if (typeof adNode !== "boolean") {
+              newNode = adNode;
+            }
+          }
+        } else if (
+          pathSegment.type === "object" ||
+          this.baseTypes.indexOf(pathSegment.type) !== -1
+        ) {
+          newNode = nodePointer;
+        } else if (pathSegment.type === "array") {
+          newNode = (nodePointer as ArrayType).elementType;
+        }
+
+        if (!newNode) {
+          continue;
+        } else if (newNode.type === "or") {
+          newPointers.push(...newNode.or);
+        } else if (newNode.type === "and") {
+          newPointers.push(...newNode.and);
+        } else if (newNode.type === "ref" && this.XLRSDK.hasType(newNode.ref)) {
+          newPointers.push(this.XLRSDK.getType(newNode.ref) as ObjectType);
+        } else {
+          newPointers.push(newNode);
+        }
+      }
+
+      if (newPointers.filter((n) => n).length === 0) {
+        break;
+      }
+
+      const newObjectTypes = newPointers.filter(
+        (n) => n.type === "object",
+      ) as ObjectType[];
+      if (newObjectTypes.length > 0) {
+        nearestObjectTypes = newObjectTypes;
+      }
+
+      pointers = newPointers;
+    }
+
+    return {
+      name: xlrInfo.name,
+      nodes: pointers,
+      nearestObjects: nearestObjectTypes,
+    };
+  }
+}

package/src/xlr/transforms.ts

@@ -0,0 +1,169 @@
+import type {
+  ArrayType,
+  OrType,
+  RefType,
+  TransformFunction,
+} from "@xlr-lib/xlr";
+import { simpleTransformGenerator } from "@xlr-lib/xlr-sdk";
+import { isPrimitiveTypeNode } from "@xlr-lib/xlr-utils";
+
+/**
+ * Adds applicability and _comment properties to Assets
+ */
+
+export const applyCommonProps: TransformFunction = (node, capability) => {
+  return simpleTransformGenerator("object", ["Assets", "Views"], (xlrNode) => {
+    if (!xlrNode.properties.applicability) {
+      xlrNode.properties.applicability = {
+        required: false,
+        node: {
+          type: "or",
+          name: "Applicability",
+          description:
+            "Evaluate the given expression (or boolean) and if falsy, remove this node from the tree. This is re-computed for each change in the data-model",
+          or: [
+            {
+              type: "boolean",
+            },
+            {
+              type: "ref",
+              ref: "Expression",
+            },
+          ],
+        },
+      };
+    }
+
+    if (!xlrNode.properties._comment) {
+      xlrNode.properties._comment = {
+        required: false,
+        node: {
+          description: "Adds a comment for the given node",
+          type: "string",
+        },
+      };
+    }
+
+    return xlrNode;
+  })(node, capability);
+};
+
+/**
+ * Replaces AssetWrapper References with AssetWrapperOrSwitch
+ */
+export const applyAssetWrapperOrSwitch: TransformFunction = (
+  node,
+  capability,
+) => {
+  return simpleTransformGenerator("ref", ["Assets", "Views"], (xlrNode) => {
+    if (xlrNode.ref.includes("AssetWrapper")) {
+      return {
+        ...xlrNode,
+        ref: xlrNode.ref.replace("AssetWrapper", "AssetWrapperOrSwitch"),
+      };
+    }
+
+    return xlrNode;
+  })(node, capability);
+};
+
+/**
+ * Modifies any primitive type property node (except id/type) to be Bindings or Expressions
+ */
+export const applyValueRefs: TransformFunction = (node, capability) => {
+  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;
+        }
+      }
+
+      return xlrNode;
+    },
+  )(node, capability);
+};
+
+/**
+ * Computes possible template keys and adds them to an Asset
+ */
+export const applyTemplateProperty: TransformFunction = (node, capability) => {
+  return simpleTransformGenerator(
+    "object",
+    ["Assets", "Views"],
+    (inputNode) => {
+      const templateTypes: Array<RefType> = [];
+      const xlrNode = { ...inputNode };
+      for (const key in xlrNode.properties) {
+        const value = xlrNode.properties[key];
+        if (value.node.type === "array") {
+          value.required = false;
+          templateTypes.push({
+            type: "ref",
+            ref: `Template<${
+              value.node.elementType.type === "ref"
+                ? value.node.elementType.ref
+                : value.node.elementType.name
+            }, "${key}">`,
+            genericArguments: [
+              value.node.elementType,
+              {
+                type: "string",
+                const: key,
+              },
+            ],
+          });
+        }
+      }
+
+      if (templateTypes.length > 0) {
+        const templateType: ArrayType = {
+          type: "array",
+          elementType:
+            templateTypes.length > 1
+              ? { type: "or", or: templateTypes }
+              : templateTypes[0],
+          description: "A list of templates to process for this node",
+        };
+        xlrNode.properties.template = {
+          required: false,
+          node: templateType,
+        };
+      }
+
+      return xlrNode;
+    },
+  )(node, capability);
+};

package/types/constants.d.ts

@@ -0,0 +1,7 @@
+import type { Filters } from "@xlr-lib/xlr-sdk";
+import { TransformFunction } from "@xlr-lib/xlr";
+import type { PlayerLanguageServicePlugin } from ".";
+export declare const PLUGINS: Array<PlayerLanguageServicePlugin>;
+export declare const DEFAULT_FILTERS: Filters;
+export declare const TRANSFORM_FUNCTIONS: Array<TransformFunction>;
+//# sourceMappingURL=constants.d.ts.map

package/types/index.d.ts

@@ -0,0 +1,69 @@
+import type { TextDocument } from "vscode-languageserver-textdocument";
+import { AsyncParallelHook, SyncBailHook, SyncHook, SyncWaterfallHook } from "tapable-ts";
+import type { CodeAction, CodeActionContext, CompletionItem, Diagnostic, FormattingOptions, Hover, Position, Location } from "vscode-languageserver-types";
+import { CompletionList, Range, TextEdit } from "vscode-languageserver-types";
+import type { TransformFunction } from "@xlr-lib/xlr";
+import type { DocumentContext, ValidationContext, CompletionContext, EnhancedDocumentContextWithPosition, Violation } from "./types";
+import { XLRService } from "./xlr";
+import { TSManifest } from "@xlr-lib/xlr";
+export * from "./utils";
+export * from "./constants";
+export * from "./types";
+export * from "./parser";
+export * from "./xlr/index";
+export interface PlayerLanguageServicePlugin {
+    /** The name of the plugin */
+    name: string;
+    /** the handle to get the LSP */
+    apply(languageService: PlayerLanguageService): void;
+}
+/** The thing that handles most of the LSP work */
+export declare class PlayerLanguageService {
+    readonly XLRService: XLRService;
+    private parseCache;
+    private fixableViolationsForDocument;
+    readonly hooks: {
+        onDocumentUpdate: SyncHook<[DocumentContext], Record<string, any>>;
+        validate: AsyncParallelHook<[DocumentContext, ValidationContext], void>;
+        onValidateEnd: SyncWaterfallHook<[
+            Diagnostic[],
+            {
+                /** The context of the document */
+                documentContext: DocumentContext;
+                /** A callback for adding a new fixable rule */
+                addFixableViolation: (diag: Diagnostic, violation: Violation) => void;
+            }
+        ], Record<string, any>>;
+        complete: AsyncParallelHook<[
+            EnhancedDocumentContextWithPosition,
+            CompletionContext
+        ], void>;
+        hover: SyncBailHook<[
+            EnhancedDocumentContextWithPosition
+        ], Hover | undefined, Record<string, any>>;
+        definition: SyncBailHook<[
+            EnhancedDocumentContextWithPosition
+        ], Location | undefined, Record<string, any>>;
+    };
+    constructor(config?: {
+        /** A list of plugins to include */
+        plugins?: Array<PlayerLanguageServicePlugin>;
+    });
+    private parseTextDocument;
+    private updateSource;
+    private getJSONPositionInfo;
+    private updateSourceWithPosition;
+    onClose(document: TextDocument): void;
+    formatTextDocument(document: TextDocument, options: FormattingOptions, range?: Range): Promise<Array<TextEdit> | undefined>;
+    validateTextDocument(document: TextDocument): Promise<Array<Diagnostic> | undefined>;
+    getCompletionsAtPosition(document: TextDocument, position: Position): Promise<CompletionList>;
+    resolveCompletionItem(completionItem: CompletionItem): Promise<CompletionItem>;
+    getHoverInfoAtPosition(document: TextDocument, position: Position): Promise<Hover | undefined | null>;
+    getCodeActionsInRange(document: TextDocument, context: CodeActionContext): Promise<CodeAction[]>;
+    getDefinitionAtPosition(document: TextDocument, position: Position): Promise<Location | undefined | null>;
+    addXLRTransforms(transforms: Record<string, TransformFunction>): void;
+    addLSPPlugin(plugin: PlayerLanguageServicePlugin): void;
+    setAssetTypes(typeFiles: Array<string>): Promise<void>;
+    setAssetTypesFromModule(manifest: Array<TSManifest>): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/types/parser/document.d.ts

@@ -0,0 +1,25 @@
+import type { Node } from "jsonc-parser";
+import type { Diagnostic } from "vscode-languageserver-types";
+import type { TextDocument } from "vscode-languageserver-textdocument";
+import type { ASTNode } from "./types";
+/**
+ * The top level document
+ */
+export declare class PlayerContent {
+    readonly root: ASTNode;
+    readonly syntaxErrors: Array<Diagnostic>;
+    private readonly jsonNodeToNode;
+    constructor(root: ASTNode, errors: Array<Diagnostic>, jsonToNodeMap: Map<Node, ASTNode>);
+    getNodeFromOffset(offset: number): ASTNode | undefined;
+}
+export declare enum ObjType {
+    FLOW = 0,
+    ASSET = 1,
+    ASSET_WRAPPER = 2,
+    UNKNOWN = 3
+}
+/** Try to identify any object as an Asset or Flow  */
+export default function identify(node: Node): ObjType;
+/** parse a text document into a player one */
+export declare function parse(document: TextDocument): PlayerContent;
+//# sourceMappingURL=document.d.ts.map

package/types/parser/edits.d.ts

@@ -0,0 +1,10 @@
+import type { TextDocument } from "vscode-languageserver-textdocument";
+import { TextEdit, Range } from "vscode-languageserver-types";
+import type { StringASTNode, NodeEdit, ASTNode } from "./types";
+/** Create a NodeEdit by replacing a string */
+export declare function replaceString(node: StringASTNode, newText: string): NodeEdit;
+/** Get the range for a given node */
+export declare function toRange(document: TextDocument, node: ASTNode): Range;
+/** Convert a NodeEdit to a TextEdit */
+export declare function toTextEdit(document: TextDocument, edit: NodeEdit): TextEdit;
+//# sourceMappingURL=edits.d.ts.map

package/types/parser/index.d.ts

@@ -0,0 +1,16 @@
+import type { TextDocument } from "vscode-languageserver-textdocument";
+import type { PlayerContent } from "./document";
+import type { ASTNode } from "./types";
+export * from "./utils";
+export { parse } from "./document";
+export * from "./types";
+export * from "./document";
+export interface PlayerContentProvider {
+    parse(document: TextDocument): PlayerContent;
+}
+/** traverse a node and call the visitor for each nested item */
+export declare function walk(node: ASTNode, visitor: (n: ASTNode) => Promise<boolean>): Promise<void>;
+/** Get the JSON value for a node */
+export declare function getNodeValue(node: ASTNode): any;
+export * from "./edits";
+//# sourceMappingURL=index.d.ts.map

package/types/parser/jsonParseErrors.d.ts

@@ -0,0 +1,27 @@
+import { Diagnostic } from "vscode-languageserver-types";
+import type { ParseError } from "jsonc-parser";
+import type { TextDocument } from "vscode-languageserver-textdocument";
+declare enum ParseErrorCode {
+    InvalidSymbol = 1,
+    InvalidNumberFormat = 2,
+    PropertyNameExpected = 3,
+    ValueExpected = 4,
+    ColonExpected = 5,
+    CommaExpected = 6,
+    CloseBraceExpected = 7,
+    CloseBracketExpected = 8,
+    EndOfFileExpected = 9,
+    InvalidCommentToken = 10,
+    UnexpectedEndOfComment = 11,
+    UnexpectedEndOfString = 12,
+    UnexpectedEndOfNumber = 13,
+    InvalidUnicode = 14,
+    InvalidEscapeCharacter = 15,
+    InvalidCharacter = 16
+}
+/** Just what the function says */
+export declare function prettyPrintParseErrorCode(code: ParseErrorCode): string;
+/** Convert any JSON parsing errors to LSP diagnostics */
+export declare function convertErrorsToDiags(document: TextDocument, errors: Array<ParseError>): Array<Diagnostic>;
+export {};
+//# sourceMappingURL=jsonParseErrors.d.ts.map