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

package/types/parser/types.d.ts

@@ -0,0 +1,188 @@
+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[];
+}
+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;
+}
+export interface ObjectASTNode<T extends string = "object"> extends BaseASTNode<T> {
+    /** an array of properties of this object */
+    properties: Array<PropertyASTNode>;
+}
+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 declare abstract class ASTNodeImpl {
+    readonly parent: ASTNode | undefined;
+    readonly jsonNode: Node;
+    constructor(jsonNode: Node, parent: ASTNode | undefined);
+}
+/** An implementation of a string node */
+export declare class StringASTNodeImpl extends ASTNodeImpl implements StringASTNode {
+    type: "string";
+    value: string;
+    constructor(jsonNode: Node, parent?: ASTNode);
+}
+/** An implementation of the number node */
+export declare class NumberASTNodeImpl extends ASTNodeImpl implements NumberASTNode {
+    type: "number";
+    value: number;
+    constructor(jsonNode: Node, parent?: ASTNode);
+}
+/** An implementation of a boolean node */
+export declare class BooleanASTNodeImpl extends ASTNodeImpl implements BooleanASTNode {
+    type: "boolean";
+    value: boolean;
+    constructor(jsonNode: Node, parent?: ASTNode);
+}
+/** An implementation of a null node */
+export declare class NullASTNodeImpl extends ASTNodeImpl implements NullASTNode {
+    type: "null";
+    value: null;
+}
+/** An implementation of a property node */
+export declare class PropertyASTNodeImpl extends ASTNodeImpl implements PropertyASTNode {
+    type: "property";
+    keyNode: StringASTNode;
+    valueNode?: ASTNode;
+    constructor(jsonNode: Node, parent: ASTNode | undefined, keyNode: StringASTNode);
+    get children(): ASTNode[];
+}
+/** An implementation of a view node */
+export declare class ViewASTNodeImpl extends ASTNodeImpl implements ViewASTNode {
+    type: "view";
+    properties: PropertyASTNode[];
+    id?: PropertyASTNode<StringASTNode>;
+    viewType?: PropertyASTNode<StringASTNode>;
+    get children(): PropertyASTNode<ASTNode>[];
+}
+/** An implementation of a top flow node */
+export declare class ContentASTNodeImpl extends ASTNodeImpl implements ContentASTNode {
+    type: "content";
+    properties: PropertyASTNode[];
+    views?: PropertyASTNode<ArrayASTNode>;
+    navigation?: PropertyASTNode<NavigationASTNode>;
+    get children(): PropertyASTNode<ASTNode>[];
+}
+/** An implementation of a navigation node */
+export declare class NavigationASTNodeImpl extends ASTNodeImpl implements NavigationASTNode {
+    type: "navigation";
+    properties: PropertyASTNode[];
+    begin?: PropertyASTNode<StringASTNode>;
+    flows: Array<PropertyASTNode<FlowASTNode>>;
+    get children(): PropertyASTNode<ASTNode>[];
+}
+/** An implementation of a flow node */
+export declare class FlowASTNodeImpl extends ASTNodeImpl implements FlowASTNode {
+    type: "flow";
+    properties: PropertyASTNode[];
+    start?: PropertyASTNode<StringASTNode>;
+    states: Array<PropertyASTNode<FlowStateASTNode>>;
+    get children(): PropertyASTNode<ASTNode>[];
+}
+/** An implementation of a flow-state node */
+export declare class FlowStateASTNodeImpl extends ASTNodeImpl implements FlowStateASTNode {
+    type: "state";
+    properties: PropertyASTNode[];
+    stateType?: PropertyASTNode<StringASTNode>;
+    get children(): PropertyASTNode<ASTNode>[];
+}
+/** An implementation of an asset node */
+export declare class AssetASTNodeImpl extends ASTNodeImpl implements AssetASTNode {
+    type: "asset";
+    properties: PropertyASTNode[];
+    id?: PropertyASTNode<StringASTNode>;
+    assetType?: PropertyASTNode<StringASTNode>;
+    get children(): PropertyASTNode<ASTNode>[];
+}
+/** An implementation of a array node */
+export declare class ArrayASTNodeImpl extends ASTNodeImpl implements ArrayASTNode {
+    type: "array";
+    items: ASTNode[];
+    get children(): ASTNode[];
+}
+/** An implementation of an object node */
+export declare class ObjectASTNodeImpl extends ASTNodeImpl implements ObjectASTNode {
+    type: "object";
+    properties: PropertyASTNode[];
+    get children(): PropertyASTNode<ASTNode>[];
+}
+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;
+}
+//# sourceMappingURL=types.d.ts.map

package/types/parser/utils.d.ts

@@ -0,0 +1,26 @@
+import type { ASTNode, PropertyASTNode, StringASTNode, ViewASTNode, ContentASTNode, FlowStateASTNode, ObjectASTNode, FlowASTNode, NavigationASTNode, AssetASTNode } from "./types";
+/** check if the node is a property */
+export declare function isPropertyNode(node?: ASTNode): node is PropertyASTNode;
+/** check if the node is an object ast */
+export declare function isObjectNode(node?: ASTNode): node is ObjectASTNode;
+/** check if the node is a key */
+export declare function isKeyNode(node?: ASTNode): node is StringASTNode;
+/** check if the node is a value */
+export declare function isValueNode(node?: ASTNode): boolean;
+/** check if the node is a view */
+export declare function isViewNode(node?: ASTNode): node is ViewASTNode;
+/** check if the node is a state */
+export declare function isStateNode(node?: ASTNode): node is FlowStateASTNode;
+/** check if the node is a flow */
+export declare function isFlowNode(node?: ASTNode): node is FlowASTNode;
+/** check if the node is a nav */
+export declare function isNavigationNode(node?: ASTNode): node is NavigationASTNode;
+/** get the value for a given key in the object */
+export declare function getValForKey<T extends ObjectASTNode<any>>(node: T, key: string): any;
+/** get the key for the given value node */
+export declare function getPropForValNode(node?: ASTNode): string | undefined;
+/** find the view node */
+export declare function getViewNode(node: ASTNode): ViewASTNode | AssetASTNode | undefined;
+/** traverse up until we find the root content node */
+export declare function getContentNode(node: ASTNode): ContentASTNode | undefined;
+//# sourceMappingURL=utils.d.ts.map

package/types/plugins/asset-wrapper-array-plugin.d.ts

@@ -0,0 +1,9 @@
+import type { PlayerLanguageService, PlayerLanguageServicePlugin } from "..";
+/**
+ * Looks for an array where there _should_ be an AssetWrapper
+ */
+export declare class AssetWrapperArrayPlugin implements PlayerLanguageServicePlugin {
+    name: string;
+    apply(service: PlayerLanguageService): void;
+}
+//# sourceMappingURL=asset-wrapper-array-plugin.d.ts.map

package/types/plugins/binding-schema-plugin.d.ts

@@ -0,0 +1,15 @@
+import type { PlayerLanguageService, PlayerLanguageServicePlugin } from "..";
+/**
+ *
+ * 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 declare class SchemaInfoPlugin implements PlayerLanguageServicePlugin {
+    name: string;
+    apply(service: PlayerLanguageService): void;
+}
+//# sourceMappingURL=binding-schema-plugin.d.ts.map

package/types/plugins/duplicate-id-plugin.d.ts

@@ -0,0 +1,7 @@
+import type { PlayerLanguageService, PlayerLanguageServicePlugin } from "..";
+/** The plugin to enable duplicate id checking/fixing */
+export declare class DuplicateIDPlugin implements PlayerLanguageServicePlugin {
+    name: string;
+    apply(service: PlayerLanguageService): void;
+}
+//# sourceMappingURL=duplicate-id-plugin.d.ts.map

package/types/plugins/missing-asset-wrapper-plugin.d.ts

@@ -0,0 +1,9 @@
+import type { PlayerLanguageService, PlayerLanguageServicePlugin } from "..";
+/**
+ * A plugin to help identify and fix the issue of forgetting the "asset" wrapper object
+ */
+export declare class MissingAssetWrapperPlugin implements PlayerLanguageServicePlugin {
+    name: string;
+    apply(languageService: PlayerLanguageService): void;
+}
+//# sourceMappingURL=missing-asset-wrapper-plugin.d.ts.map

package/types/plugins/nav-state-plugin.d.ts

@@ -0,0 +1,9 @@
+import type { PlayerLanguageService, PlayerLanguageServicePlugin } from "..";
+/**
+ * Handles everything associated with navigation nodes (transitions, jump-to-def, reachability)
+ */
+export declare class NavStatePlugin implements PlayerLanguageServicePlugin {
+    name: string;
+    apply(service: PlayerLanguageService): void;
+}
+//# sourceMappingURL=nav-state-plugin.d.ts.map

package/types/plugins/view-node-plugin.d.ts

@@ -0,0 +1,9 @@
+import type { PlayerLanguageService, PlayerLanguageServicePlugin } from "..";
+/**
+ * Handles everything associated with the VIEW node type (definition, validation, auto-complete)
+ */
+export declare class ViewNodePlugin implements PlayerLanguageServicePlugin {
+    name: string;
+    apply(service: PlayerLanguageService): void;
+}
+//# sourceMappingURL=view-node-plugin.d.ts.map

package/types/plugins/xlr-plugin.d.ts

@@ -0,0 +1,7 @@
+import type { PlayerLanguageService, PlayerLanguageServicePlugin } from "..";
+/** The plugin to enable duplicate id checking/fixing */
+export declare class XLRPlugin implements PlayerLanguageServicePlugin {
+    name: string;
+    apply(service: PlayerLanguageService): void;
+}
+//# sourceMappingURL=xlr-plugin.d.ts.map

package/types/types.d.ts

@@ -0,0 +1,81 @@
+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 declare const LOG_TYPES: readonly ["debug", "info", "warn", "error"];
+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;
+}
+//# sourceMappingURL=types.d.ts.map

package/types/utils.d.ts

@@ -0,0 +1,24 @@
+import { Range, Location } from "vscode-languageserver-types";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import type { ASTNode, PlayerContent, PropertyASTNode } from "./parser";
+import type { ASTVisitor } from "./types";
+export declare const typeToVisitorMap: Record<ASTNode["type"], keyof ASTVisitor>;
+/** Check to see if the source range contains the target one */
+export declare function containsRange(source: Range, range: Range): boolean;
+/** Create a dummy TextDocument from the given string */
+export declare function toTextDocument(str: string): TextDocument;
+/** Check to see if the document successfully parsed into a known root type */
+export declare function isKnownRootType(document: PlayerContent): boolean;
+/** Check to see if the node is the value of an object */
+export declare function isValueCompletion(node: ASTNode): boolean;
+/** Check to see if the node is the key of an object */
+export declare function isPropertyCompletion(node: ASTNode): boolean;
+/** Search the object for a property with the given name */
+export declare function getProperty<T extends ASTNode>(obj: T, name: string): PropertyASTNode | undefined;
+/** Get the LSP Location of an AST node in a document */
+export declare function getLSLocationOfNode(document: TextDocument, node: ASTNode): Location;
+/** Format a new node like an existing one (including the indentation) */
+export declare function formatLikeNode(document: TextDocument, originalNode: ASTNode, replacement: Record<string, unknown>): string;
+/** Maps the string identifying the FlowType to the named type */
+export declare function mapFlowStateToType(flowType: string | undefined): string | undefined;
+//# sourceMappingURL=utils.d.ts.map

package/types/xlr/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./registry";
+export * from "./service";
+export * from "./transforms";
+//# sourceMappingURL=index.d.ts.map

package/types/xlr/registry.d.ts

@@ -0,0 +1,17 @@
+import type { Filters, TypeMetadata } from "@xlr-lib/xlr-sdk";
+import { BasicXLRRegistry } from "@xlr-lib/xlr-sdk";
+import type { NamedType, NodeType } from "@xlr-lib/xlr";
+/**
+ * Player specific implementation of a XLRs Registry
+ */
+export declare class PlayerXLRRegistry extends BasicXLRRegistry {
+    /** Keeps the mapping of how a type is referenced by Player to the underlying XLR */
+    private registrationMap;
+    constructor();
+    get(id: string): NamedType<NodeType> | undefined;
+    add(type: NamedType<NodeType>, plugin: string, capability: string): void;
+    has(id: string): boolean;
+    list(filterArgs?: Filters): NamedType<NodeType>[];
+    info(id: string): TypeMetadata | undefined;
+}
+//# sourceMappingURL=registry.d.ts.map

package/types/xlr/service.d.ts

@@ -0,0 +1,22 @@
+import { XLRSDK } from "@xlr-lib/xlr-sdk";
+import type { NodeType, ObjectType } from "@xlr-lib/xlr";
+import type { ASTNode } from "../parser";
+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 declare class XLRService {
+    private baseTypes;
+    XLRSDK: XLRSDK;
+    constructor();
+    private walker;
+    getTypeInfoAtPosition(node: ASTNode | undefined): XLRContext | undefined;
+}
+//# sourceMappingURL=service.d.ts.map

package/types/xlr/transforms.d.ts

@@ -0,0 +1,18 @@
+import type { TransformFunction } from "@xlr-lib/xlr";
+/**
+ * Adds applicability and _comment properties to Assets
+ */
+export declare const applyCommonProps: TransformFunction;
+/**
+ * Replaces AssetWrapper References with AssetWrapperOrSwitch
+ */
+export declare const applyAssetWrapperOrSwitch: TransformFunction;
+/**
+ * Modifies any primitive type property node (except id/type) to be Bindings or Expressions
+ */
+export declare const applyValueRefs: TransformFunction;
+/**
+ * Computes possible template keys and adds them to an Asset
+ */
+export declare const applyTemplateProperty: TransformFunction;
+//# sourceMappingURL=transforms.d.ts.map