@player-tools/json-language-service 0.2.2--canary.20.454

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 '@player-tools/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) {
+    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,118 @@
+import { DiagnosticSeverity } from 'vscode-languageserver-types';
+import type { AssetASTNode, ASTNode, ViewASTNode } from '../parser';
+import { getViewNode, replaceString } from '../parser';
+import type { PlayerLanguageService, PlayerLanguageServicePlugin } from '..';
+import type { Violation, ValidationContext, ASTVisitor } from '../types';
+
+/** 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);
+
+      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) {
+    service.hooks.validate.tap(this.name, async (ctx, validation) => {
+      validation.useASTVisitor(createValidationVisitor(validation));
+    });
+  }
+}

package/src/plugins/legacy-action-plugin.ts

@@ -0,0 +1,79 @@
+import { DiagnosticSeverity } from 'vscode-languageserver-types';
+import type { PlayerLanguageService, PlayerLanguageServicePlugin } from '..';
+import type { ASTNode } from '../parser';
+import { getNodeValue } from '../parser';
+import type { ASTVisitor, ValidationContext } from '../types';
+
+/** Create an AST visitor for checking the legacy action */
+function createRuleVisitor(context: ValidationContext): ASTVisitor {
+  /** Check if a node is using the action asset or not */
+  const checkForLegacyAction = (node: ASTNode) => {
+    if (node.type === 'asset') {
+      return;
+    }
+
+    if (
+      node.type === 'object' &&
+      !node.properties.some(
+        (p) =>
+          p.keyNode.value === 'asset' ||
+          p.keyNode.value === 'dynamicSwitch' ||
+          p.keyNode.value === 'staticSwitch'
+      )
+    ) {
+      context.addViolation({
+        message: 'Migrate to an action-asset',
+        node,
+        severity: DiagnosticSeverity.Warning,
+        fix: () => {
+          const newActionAsset = {
+            asset: {
+              type: 'action',
+              ...getNodeValue(node),
+            },
+          };
+
+          return {
+            name: 'Convert to Asset',
+            edit: {
+              type: 'replace',
+              node,
+              value: JSON.stringify(newActionAsset, null, 2),
+            },
+          };
+        },
+      });
+    }
+  };
+
+  return {
+    ViewNode: (viewNode) => {
+      // Check for an `actions` array of non-assets
+
+      const actionsProp = viewNode.properties.find(
+        (p) => p.keyNode.value === 'actions'
+      );
+
+      if (!actionsProp || actionsProp.valueNode?.type !== 'array') {
+        return;
+      }
+
+      // Go through the array and add a violation/fix for anything that's not an asset
+
+      actionsProp.valueNode.children.forEach((action) => {
+        checkForLegacyAction(action);
+      });
+    },
+  };
+}
+
+/** A plugin that validates and corrects the usage of non-asset actions in a view */
+export class LegacyActionPlugin implements PlayerLanguageServicePlugin {
+  name = 'legacy-action';
+
+  apply(service: PlayerLanguageService) {
+    service.hooks.validate.tap(this.name, async (ctx, validationContext) => {
+      validationContext.useASTVisitor(createRuleVisitor(validationContext));
+    });
+  }
+}

package/src/plugins/legacy-template-plugin.ts

@@ -0,0 +1,125 @@
+import { addLast, omit, set } from 'timm';
+import { DiagnosticSeverity } from 'vscode-languageserver-types';
+import type { PlayerLanguageService, PlayerLanguageServicePlugin } from '..';
+import type { AssetASTNode, ObjectASTNode, ViewASTNode } from '../parser';
+import { getNodeValue } from '../parser';
+import type {
+  ASTVisitor,
+  DocumentContext,
+  ValidationContext,
+  Violation,
+} from '../types';
+import { formatLikeNode } from '../utils';
+
+/** Create a visitor for handling old template syntax */
+function createRuleVisitor(
+  context: ValidationContext,
+  docInfo: DocumentContext
+): ASTVisitor {
+  /** Check a node for any signs of a legacy-template */
+  const checkForLegacyTemplate = (
+    node: ObjectASTNode | AssetASTNode | ViewASTNode
+  ) => {
+    // check if it has any of the 3 props we care about
+
+    const templateDataProp = node.properties.find(
+      (p) => p.keyNode.value === 'templateData'
+    );
+    const templateValueProp = node.properties.find(
+      (p) => p.keyNode.value === 'template'
+    );
+    const templateOutputProp = node.properties.find(
+      (p) => p.keyNode.value === 'templateOutput'
+    );
+
+    // If we don't have any of those props, or we just have the`template` prop and it points to an array, skip it all, we good.
+    if (
+      !templateDataProp &&
+      !templateOutputProp &&
+      (!templateValueProp || templateValueProp.valueNode?.type === 'array')
+    ) {
+      return;
+    }
+
+    const templateViolation: Omit<Violation, 'node'> = {
+      severity: DiagnosticSeverity.Error,
+      message: `Migrate to the template[] syntax.`,
+      fix: () => {
+        // Create the new template object;
+        const path = [
+          'template',
+          templateValueProp?.valueNode?.type === 'array'
+            ? templateValueProp.valueNode.children.length
+            : 0,
+        ];
+
+        const newTemplateObj = {
+          value:
+            templateValueProp?.valueNode?.type !== 'array' &&
+            templateValueProp?.valueNode
+              ? getNodeValue(templateValueProp?.valueNode)
+              : {},
+          output: templateOutputProp?.valueNode?.jsonNode.value ?? '',
+          data: templateDataProp?.valueNode?.jsonNode.value ?? '',
+        };
+
+        const oldValue = getNodeValue(node);
+        let newValue = omit(oldValue, 'templateData');
+        newValue = omit(newValue, 'templateOutput');
+
+        if (templateValueProp?.valueNode?.type !== 'array') {
+          newValue = omit(newValue, 'template');
+        }
+
+        newValue = set(
+          newValue,
+          'template',
+          addLast(newValue.template ?? [], newTemplateObj)
+        );
+
+        return {
+          edit: {
+            type: 'replace',
+            path,
+            node,
+            value: formatLikeNode(docInfo.document, node, newValue),
+          },
+          name: 'Convert to template[]',
+        };
+      },
+    };
+
+    if (templateDataProp) {
+      context.addViolation({
+        ...templateViolation,
+        node: templateDataProp,
+      });
+    }
+
+    if (templateOutputProp) {
+      context.addViolation({
+        ...templateViolation,
+        node: templateOutputProp,
+      });
+    }
+  };
+
+  return {
+    ViewNode: checkForLegacyTemplate,
+    AssetNode: checkForLegacyTemplate,
+    ObjectNode: checkForLegacyTemplate,
+  };
+}
+
+/** A plugin that handles the old legacy template syntax */
+export class LegacyTemplatePlugin implements PlayerLanguageServicePlugin {
+  name = 'legacy-template';
+
+  apply(service: PlayerLanguageService) {
+    service.hooks.validate.tap(this.name, async (ctx, validationContext) => {
+      validationContext.useASTVisitor(
+        createRuleVisitor(validationContext, ctx)
+      );
+    });
+  }
+}

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;
+      }
+    );
+  }
+}