@player-tools/typescript-expression-plugin 0.4.2-next.1 → 0.5.0-next.0

package/src/logger.ts

@@ -1,5 +1,5 @@
-import type { Logger } from 'typescript-template-language-service-decorator';
-import type * as ts from 'typescript/lib/tsserverlibrary';
+import type { Logger } from "typescript-template-language-service-decorator";
+import ts from "typescript/lib/tsserverlibrary";
 
 export class LSPLogger implements Logger {
   private readonly info: ts.server.PluginCreateInfo;

package/src/service.ts

@@ -1,20 +1,20 @@
-import * as ts from 'typescript/lib/tsserverlibrary';
+import ts from "typescript/lib/tsserverlibrary";
 import type {
   TemplateLanguageService,
   TemplateContext,
   Logger,
-} from 'typescript-template-language-service-decorator';
-import type { FunctionType, TSManifest, NodeType } from '@player-tools/xlr';
-import { createTSDocString } from '@player-tools/xlr-utils';
-import { XLRSDK } from '@player-tools/xlr-sdk';
-import type { ExpressionNode } from '@player-ui/player';
-import { parseExpression } from '@player-ui/player';
+} from "typescript-template-language-service-decorator";
+import type { FunctionType, TSManifest, NodeType } from "@player-tools/xlr";
+import { createTSDocString } from "@player-tools/xlr-utils";
+import { XLRSDK } from "@player-tools/xlr-sdk";
+import type { ExpressionNode } from "@player-ui/player";
+import { parseExpression } from "@player-ui/player";
 import {
   getTokenAtPosition,
   toTSLocation,
   convertExprToJSONNode,
-} from './utils';
-import { toFunction } from './transforms';
+} from "./utils";
+import { toFunction } from "./transforms";
 
 interface ExpressionEntry {
   /**
@@ -86,8 +86,8 @@ export class ExpressionLanguageService implements TemplateLanguageService {
       );
 
       if (
-        type.type === 'function' &&
-        typeInfo?.capability === 'Expressions' &&
+        type.type === "function" &&
+        typeInfo?.capability === "Expressions" &&
         source
       ) {
         expressions.set(type.name, {
@@ -134,7 +134,7 @@ export class ExpressionLanguageService implements TemplateLanguageService {
     const parsed = parseExpression(line, { strict: false });
     const token = getTokenAtPosition(parsed, position);
 
-    if (token?.type === 'Compound' && token.error) {
+    if (token?.type === "Compound" && token.error) {
       // We hit the end of the expression, and it's expecting more
       // so provide all the completions
       this._expressions.forEach((exp) => {
@@ -150,7 +150,7 @@ export class ExpressionLanguageService implements TemplateLanguageService {
       return completionInfo;
     }
 
-    if (token?.type === 'Identifier') {
+    if (token?.type === "Identifier") {
       // get the relevant start of the identifier
       const start = token.location?.start ?? { character: 0 };
       const wordFromStart = line.slice(start.character, position.character);
@@ -186,8 +186,8 @@ export class ExpressionLanguageService implements TemplateLanguageService {
 
       documentation: [
         {
-          kind: 'text',
-          text: expression?.type.description ?? '',
+          kind: "text",
+          text: expression?.type.description ?? "",
         },
       ],
       displayParts: expression ? createTSDocString(expression.type) : [],
@@ -203,7 +203,7 @@ export class ExpressionLanguageService implements TemplateLanguageService {
     const parsed = parseExpression(context.text, { strict: false });
     const token = getTokenAtPosition(parsed, position);
 
-    if (token?.type === 'Identifier') {
+    if (token?.type === "Identifier") {
       const expression = this._expressions.get(token.name);
 
       if (expression) {
@@ -254,13 +254,13 @@ export class ExpressionLanguageService implements TemplateLanguageService {
   ): ts.Diagnostic[] {
     const diags: ts.Diagnostic[] = [];
 
-    if (node.type === 'Compound') {
+    if (node.type === "Compound") {
       node.body.forEach((n) => {
         diags.push(...this.getDiagnosticsForNode(context, n));
       });
     }
 
-    if (node.type === 'CallExpression') {
+    if (node.type === "CallExpression") {
       // Check that the expression is valid
       const exprName = node.callTarget.name;
       const expression = this._expressions.get(exprName);

package/src/transforms.ts

@@ -1,18 +1,18 @@
-import type { FunctionType, FunctionTypeParameters } from '@player-tools/xlr';
-import { simpleTransformGenerator } from '@player-tools/xlr-sdk';
+import type { FunctionType, FunctionTypeParameters } from "@player-tools/xlr";
+import { simpleTransformGenerator } from "@player-tools/xlr-sdk";
 
 export const toFunction = simpleTransformGenerator(
-  'ref',
-  'Expressions',
+  "ref",
+  "Expressions",
   (exp) => {
-    if (!exp.genericArguments || exp.ref !== 'ExpressionHandler') {
+    if (!exp.genericArguments || exp.ref !== "ExpressionHandler") {
       return exp;
     }
 
     const [args, returnType] = exp.genericArguments;
 
     const parameters: Array<FunctionTypeParameters> = (
-      args.type === 'tuple' ? args.elementTypes : []
+      args.type === "tuple" ? args.elementTypes : []
     ).map((elementType, index) => {
       return {
         name:
@@ -36,7 +36,7 @@ export const toFunction = simpleTransformGenerator(
 
     return {
       ...exp,
-      type: 'function',
+      type: "function",
       parameters,
       returnType,
     } as FunctionType as any;

package/src/utils.ts

@@ -1,7 +1,7 @@
-import type { Position } from 'vscode-languageserver-types';
-import type { ExpressionNode, NodeLocation } from '@player-ui/player';
-import { parseTree } from 'jsonc-parser';
-import type { Node } from 'jsonc-parser';
+import type { Position } from "vscode-languageserver-types";
+import type { ExpressionNode, NodeLocation } from "@player-ui/player";
+import { parseTree } from "jsonc-parser";
+import type { Node } from "jsonc-parser";
 
 /** Check if the vscode position overlaps with the expression location */
 export function isInRange(position: Position, location: NodeLocation) {
@@ -16,7 +16,7 @@ export function getTokenAtPosition(
   node: ExpressionNode,
   position: Position
 ): ExpressionNode | undefined {
-  if (node.type === 'CallExpression') {
+  if (node.type === "CallExpression") {
     const anyArgs = node.args.find((arg) => {
       return getTokenAtPosition(arg, position);
     });
@@ -31,7 +31,7 @@ export function getTokenAtPosition(
     }
   }
 
-  if (node.type === 'Assignment') {
+  if (node.type === "Assignment") {
     const asTarget =
       getTokenAtPosition(node.left, position) ??
       getTokenAtPosition(node.right, position);
@@ -67,14 +67,14 @@ export function toTSLocation(node: ExpressionNode): ts.TextSpan {
 export function convertExprToValue(exprNode: ExpressionNode): any {
   let val;
 
-  if (exprNode.type === 'Literal') {
+  if (exprNode.type === "Literal") {
     val = exprNode.value;
-  } else if (exprNode.type === 'Object') {
+  } else if (exprNode.type === "Object") {
     val = {};
     exprNode.attributes.forEach((prop) => {
       val[convertExprToValue(prop.key)] = convertExprToValue(prop.value);
     });
-  } else if (exprNode.type === 'ArrayExpression') {
+  } else if (exprNode.type === "ArrayExpression") {
     val = exprNode.elements.map(convertExprToValue);
   }
 

package/src/virtual-service-host.ts

@@ -1,4 +1,4 @@
-import type * as ts from 'typescript/lib/tsserverlibrary';
+import ts from "typescript/lib/tsserverlibrary";
 
 export default class VirtualServiceHost implements ts.LanguageServiceHost {
   private readonly files = new Map<string, string>();
@@ -36,7 +36,7 @@ export default class VirtualServiceHost implements ts.LanguageServiceHost {
   }
 
   getScriptVersion() {
-    return '0';
+    return "0";
   }
 
   getScriptSnapshot(fileName: string) {
@@ -55,13 +55,13 @@ export default class VirtualServiceHost implements ts.LanguageServiceHost {
   }
 
   fileExists(path: string): boolean {
-    return path.includes('node_modules')
+    return path.includes("node_modules")
       ? this.typescript.sys.fileExists(path)
       : this.files.has(path);
   }
 
   readFile(path: string, encoding?: string | undefined): string | undefined {
-    return path.includes('node_modules')
+    return path.includes("node_modules")
       ? this.typescript.sys.readFile(path, encoding)
       : this.files.get(path);
   }

package/{dist → types}/index.d.ts

@@ -1,8 +1,7 @@
-import * as ts from 'typescript/lib/tsserverlibrary';
-
+import ts from "typescript/lib/tsserverlibrary";
 interface InitParams {
     typescript: typeof ts;
 }
 declare function init(mod: InitParams): ts.server.PluginModule;
-
-export { init as default };
+export default init;
+//# sourceMappingURL=index.d.ts.map

package/types/logger.d.ts

@@ -0,0 +1,8 @@
+import type { Logger } from "typescript-template-language-service-decorator";
+import ts from "typescript/lib/tsserverlibrary";
+export declare class LSPLogger implements Logger {
+    private readonly info;
+    constructor(info: ts.server.PluginCreateInfo);
+    log(msg: string): void;
+}
+//# sourceMappingURL=logger.d.ts.map

package/types/service.d.ts

@@ -0,0 +1,31 @@
+import ts from "typescript/lib/tsserverlibrary";
+import type { TemplateLanguageService, TemplateContext, Logger } from "typescript-template-language-service-decorator";
+import type { TSManifest } from "@player-tools/xlr";
+export interface ExpressionLanguageServiceConfig {
+    /**
+     * The list of XLR enabled plugins to load
+     */
+    plugins: Array<TSManifest>;
+}
+/**
+ * Language server to check Player expression syntax and usage
+ */
+export declare class ExpressionLanguageService implements TemplateLanguageService {
+    private logger?;
+    private _plugins;
+    private _expressions;
+    private xlr;
+    constructor(options?: {
+        logger?: Logger;
+    } & Partial<ExpressionLanguageServiceConfig>);
+    setConfig(config: ExpressionLanguageServiceConfig): void;
+    private reduceExpression;
+    getCompletionsAtPosition(context: TemplateContext, position: ts.LineAndCharacter): ts.CompletionInfo;
+    getCompletionEntryDetails(context: TemplateContext, position: ts.LineAndCharacter, name: string): ts.CompletionEntryDetails;
+    getQuickInfoAtPosition(context: TemplateContext, position: ts.LineAndCharacter): ts.QuickInfo | undefined;
+    private checkNode;
+    private getDiagnosticsForNode;
+    getSemanticDiagnostics(context: TemplateContext): ts.Diagnostic[];
+    getSyntacticDiagnostics(context: TemplateContext): ts.Diagnostic[];
+}
+//# sourceMappingURL=service.d.ts.map

package/types/transforms.d.ts

@@ -0,0 +1,2 @@
+export declare const toFunction: import("@player-tools/xlr").TransformFunction;
+//# sourceMappingURL=transforms.d.ts.map

package/types/utils.d.ts

@@ -0,0 +1,14 @@
+import type { Position } from "vscode-languageserver-types";
+import type { ExpressionNode, NodeLocation } from "@player-ui/player";
+import type { Node } from "jsonc-parser";
+/** Check if the vscode position overlaps with the expression location */
+export declare function isInRange(position: Position, location: NodeLocation): boolean;
+/** Find the closest marked token at the given position */
+export declare function getTokenAtPosition(node: ExpressionNode, position: Position): ExpressionNode | undefined;
+/** Get the location info that TS expects for it's diags */
+export declare function toTSLocation(node: ExpressionNode): ts.TextSpan;
+/** ExpressionNode -> raw value */
+export declare function convertExprToValue(exprNode: ExpressionNode): any;
+/** ExpressionNode -> JSONC Node */
+export declare function convertExprToJSONNode(exprNode: ExpressionNode): Node | undefined;
+//# sourceMappingURL=utils.d.ts.map

package/types/virtual-service-host.d.ts

@@ -0,0 +1,20 @@
+import ts from "typescript/lib/tsserverlibrary";
+export default class VirtualServiceHost implements ts.LanguageServiceHost {
+    private readonly files;
+    private readonly typescript;
+    private readonly compilerOptions;
+    private readonly workspacePath;
+    constructor(typescript: typeof ts, compilerOptions: ts.CompilerOptions, workspacePath: string);
+    withFile<T>(fileName: string, content: string, callback: () => T): T;
+    getCompilationSettings(): ts.CompilerOptions;
+    getScriptFileNames(): string[];
+    getScriptKind(): ts.ScriptKind;
+    getScriptVersion(): string;
+    getScriptSnapshot(fileName: string): ts.IScriptSnapshot | undefined;
+    getCurrentDirectory(): string;
+    getDefaultLibFileName(options: ts.CompilerOptions): string;
+    fileExists(path: string): boolean;
+    readFile(path: string, encoding?: string | undefined): string | undefined;
+    useCaseSensitiveFileNames(): boolean;
+}
+//# sourceMappingURL=virtual-service-host.d.ts.map