@player-tools/typescript-expression-plugin 0.2.2--canary.20.454

package/dist/index.cjs.js

@@ -0,0 +1,210 @@
+'use strict';
+
+var typescriptTemplateLanguageServiceDecorator = require('typescript-template-language-service-decorator');
+var ts = require('typescript/lib/tsserverlibrary');
+var player = require('@player-ui/player');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var ts__namespace = /*#__PURE__*/_interopNamespace(ts);
+
+function isInRange(position, location) {
+  return position.character >= location.start.character && position.character <= location.end.character;
+}
+function getTokenAtPosition(node, position) {
+  var _a;
+  if (node.type === "CallExpression") {
+    const anyArgs = node.args.find((arg) => {
+      return getTokenAtPosition(arg, position);
+    });
+    if (anyArgs) {
+      return anyArgs;
+    }
+    const asTarget = getTokenAtPosition(node.callTarget, position);
+    if (asTarget) {
+      return asTarget;
+    }
+  }
+  if (node.type === "Assignment") {
+    const asTarget = (_a = getTokenAtPosition(node.left, position)) != null ? _a : getTokenAtPosition(node.right, position);
+    if (asTarget) {
+      return asTarget;
+    }
+  }
+  if (node.location && isInRange(position, node.location)) {
+    return node;
+  }
+}
+
+class ExpressionLanguageService {
+  constructor(options) {
+    this._expressions = new Map();
+    this.logger = options == null ? void 0 : options.logger;
+    this.setExpressions(new Map([
+      [
+        "test",
+        {
+          name: "test",
+          description: "test expression",
+          args: []
+        }
+      ],
+      [
+        "foo",
+        {
+          name: "foo",
+          description: "Test foo expression",
+          args: [
+            {
+              name: "path",
+              type: "string"
+            }
+          ]
+        }
+      ]
+    ]));
+  }
+  setExpressions(expressionData) {
+    this._expressions = expressionData;
+  }
+  getCompletionsAtPosition(context, position) {
+    var _a, _b, _c;
+    const line = context.text.split(/\n/g)[position.line];
+    (_a = this.logger) == null ? void 0 : _a.log(`[expression-LSP] getCompletionsAtPosition: ${line} -- ${context.rawText} -- ${context.text}`);
+    const parsed = player.parseExpression(line, { strict: false });
+    const token = getTokenAtPosition(parsed, position);
+    const completionInfo = {
+      isGlobalCompletion: false,
+      isMemberCompletion: false,
+      isNewIdentifierLocation: false,
+      entries: []
+    };
+    if ((token == null ? void 0 : token.type) === "Identifier") {
+      const start = (_c = (_b = token.location) == null ? void 0 : _b.start) != null ? _c : { character: 0 };
+      const wordFromStart = line.slice(start.character, position.character);
+      const allCompletions = Array.from(this._expressions.keys()).filter((key) => key.startsWith(wordFromStart));
+      allCompletions.forEach((c) => {
+        completionInfo.entries.push({
+          name: c,
+          kind: ts__namespace.ScriptElementKind.functionElement,
+          sortText: c,
+          isRecommended: true
+        });
+      });
+    }
+    return completionInfo;
+  }
+  getQuickInfoAtPosition(context, position) {
+    var _a, _b, _c, _d, _e;
+    (_a = this.logger) == null ? void 0 : _a.log(`getCompletionsAtPosition: ${context.text}`);
+    const parsed = player.parseExpression(context.text, { strict: false });
+    const token = getTokenAtPosition(parsed, position);
+    if ((token == null ? void 0 : token.type) === "Identifier") {
+      const expression = this._expressions.get(token.name);
+      if (expression) {
+        return {
+          textSpan: {
+            start: (_c = (_b = token.location) == null ? void 0 : _b.start.character) != null ? _c : 0,
+            length: (_e = (_d = token.location) == null ? void 0 : _d.end.character) != null ? _e : 0
+          },
+          kindModifiers: ts__namespace.ScriptElementKindModifier.none,
+          kind: ts__namespace.ScriptElementKind.functionElement,
+          documentation: [
+            {
+              kind: "text",
+              text: expression.description
+            }
+          ]
+        };
+      }
+    }
+    return void 0;
+  }
+  getCompletionEntryDetails(context, position, name) {
+    var _a, _b;
+    const expression = this._expressions.get(name);
+    const prefix = [
+      {
+        text: ", ",
+        kind: ts__namespace.ScriptElementKind.unknown
+      }
+    ];
+    const completionDetails = {
+      name,
+      kind: ts__namespace.ScriptElementKind.functionElement,
+      kindModifiers: ts__namespace.ScriptElementKindModifier.none,
+      documentation: [
+        {
+          kind: "text",
+          text: (_a = expression == null ? void 0 : expression.description) != null ? _a : "Some description"
+        }
+      ],
+      displayParts: [
+        {
+          text: name,
+          kind: ts__namespace.ScriptElementKind.functionElement
+        },
+        {
+          text: "(",
+          kind: ts__namespace.ScriptElementKind.unknown
+        },
+        ...(_b = expression == null ? void 0 : expression.args.flatMap((arg, index) => [
+          ...index === 0 ? [] : prefix,
+          {
+            text: arg.name,
+            kind: ts__namespace.ScriptElementKind.parameterElement
+          },
+          {
+            text: ": ",
+            kind: ts__namespace.ScriptElementKind.unknown
+          },
+          {
+            text: arg.type,
+            kind: ts__namespace.ScriptElementKind.typeParameterElement
+          }
+        ])) != null ? _b : [],
+        {
+          text: ")",
+          kind: ts__namespace.ScriptElementKind.unknown
+        }
+      ]
+    };
+    return completionDetails;
+  }
+}
+
+class LSPLogger {
+  constructor(info) {
+    this.info = info;
+  }
+  log(msg) {
+    this.info.project.projectService.logger.info(`[player-expr-lsp] ${msg}`);
+  }
+}
+
+module.exports = (mod) => {
+  return {
+    create(info) {
+      const logger = new LSPLogger(info);
+      const templateService = new ExpressionLanguageService({ logger });
+      return typescriptTemplateLanguageServiceDecorator.decorateWithTemplateLanguageService(mod.typescript, info.languageService, info.project, templateService, { tags: ["e", "expr"], enableForStringWithSubstitutions: true }, { logger });
+    }
+  };
+};
+//# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import * as ts from 'typescript/lib/tsserverlibrary';
+
+declare const _default: (mod: {
+    typescript: typeof ts;
+}) => {
+    create(info: ts.server.PluginCreateInfo): ts.LanguageService;
+};
+
+export { _default as default };

package/dist/index.esm.js

@@ -0,0 +1,188 @@
+import { decorateWithTemplateLanguageService } from 'typescript-template-language-service-decorator';
+import * as ts from 'typescript/lib/tsserverlibrary';
+import { parseExpression } from '@player-ui/player';
+
+function isInRange(position, location) {
+  return position.character >= location.start.character && position.character <= location.end.character;
+}
+function getTokenAtPosition(node, position) {
+  var _a;
+  if (node.type === "CallExpression") {
+    const anyArgs = node.args.find((arg) => {
+      return getTokenAtPosition(arg, position);
+    });
+    if (anyArgs) {
+      return anyArgs;
+    }
+    const asTarget = getTokenAtPosition(node.callTarget, position);
+    if (asTarget) {
+      return asTarget;
+    }
+  }
+  if (node.type === "Assignment") {
+    const asTarget = (_a = getTokenAtPosition(node.left, position)) != null ? _a : getTokenAtPosition(node.right, position);
+    if (asTarget) {
+      return asTarget;
+    }
+  }
+  if (node.location && isInRange(position, node.location)) {
+    return node;
+  }
+}
+
+class ExpressionLanguageService {
+  constructor(options) {
+    this._expressions = new Map();
+    this.logger = options == null ? void 0 : options.logger;
+    this.setExpressions(new Map([
+      [
+        "test",
+        {
+          name: "test",
+          description: "test expression",
+          args: []
+        }
+      ],
+      [
+        "foo",
+        {
+          name: "foo",
+          description: "Test foo expression",
+          args: [
+            {
+              name: "path",
+              type: "string"
+            }
+          ]
+        }
+      ]
+    ]));
+  }
+  setExpressions(expressionData) {
+    this._expressions = expressionData;
+  }
+  getCompletionsAtPosition(context, position) {
+    var _a, _b, _c;
+    const line = context.text.split(/\n/g)[position.line];
+    (_a = this.logger) == null ? void 0 : _a.log(`[expression-LSP] getCompletionsAtPosition: ${line} -- ${context.rawText} -- ${context.text}`);
+    const parsed = parseExpression(line, { strict: false });
+    const token = getTokenAtPosition(parsed, position);
+    const completionInfo = {
+      isGlobalCompletion: false,
+      isMemberCompletion: false,
+      isNewIdentifierLocation: false,
+      entries: []
+    };
+    if ((token == null ? void 0 : token.type) === "Identifier") {
+      const start = (_c = (_b = token.location) == null ? void 0 : _b.start) != null ? _c : { character: 0 };
+      const wordFromStart = line.slice(start.character, position.character);
+      const allCompletions = Array.from(this._expressions.keys()).filter((key) => key.startsWith(wordFromStart));
+      allCompletions.forEach((c) => {
+        completionInfo.entries.push({
+          name: c,
+          kind: ts.ScriptElementKind.functionElement,
+          sortText: c,
+          isRecommended: true
+        });
+      });
+    }
+    return completionInfo;
+  }
+  getQuickInfoAtPosition(context, position) {
+    var _a, _b, _c, _d, _e;
+    (_a = this.logger) == null ? void 0 : _a.log(`getCompletionsAtPosition: ${context.text}`);
+    const parsed = parseExpression(context.text, { strict: false });
+    const token = getTokenAtPosition(parsed, position);
+    if ((token == null ? void 0 : token.type) === "Identifier") {
+      const expression = this._expressions.get(token.name);
+      if (expression) {
+        return {
+          textSpan: {
+            start: (_c = (_b = token.location) == null ? void 0 : _b.start.character) != null ? _c : 0,
+            length: (_e = (_d = token.location) == null ? void 0 : _d.end.character) != null ? _e : 0
+          },
+          kindModifiers: ts.ScriptElementKindModifier.none,
+          kind: ts.ScriptElementKind.functionElement,
+          documentation: [
+            {
+              kind: "text",
+              text: expression.description
+            }
+          ]
+        };
+      }
+    }
+    return void 0;
+  }
+  getCompletionEntryDetails(context, position, name) {
+    var _a, _b;
+    const expression = this._expressions.get(name);
+    const prefix = [
+      {
+        text: ", ",
+        kind: ts.ScriptElementKind.unknown
+      }
+    ];
+    const completionDetails = {
+      name,
+      kind: ts.ScriptElementKind.functionElement,
+      kindModifiers: ts.ScriptElementKindModifier.none,
+      documentation: [
+        {
+          kind: "text",
+          text: (_a = expression == null ? void 0 : expression.description) != null ? _a : "Some description"
+        }
+      ],
+      displayParts: [
+        {
+          text: name,
+          kind: ts.ScriptElementKind.functionElement
+        },
+        {
+          text: "(",
+          kind: ts.ScriptElementKind.unknown
+        },
+        ...(_b = expression == null ? void 0 : expression.args.flatMap((arg, index) => [
+          ...index === 0 ? [] : prefix,
+          {
+            text: arg.name,
+            kind: ts.ScriptElementKind.parameterElement
+          },
+          {
+            text: ": ",
+            kind: ts.ScriptElementKind.unknown
+          },
+          {
+            text: arg.type,
+            kind: ts.ScriptElementKind.typeParameterElement
+          }
+        ])) != null ? _b : [],
+        {
+          text: ")",
+          kind: ts.ScriptElementKind.unknown
+        }
+      ]
+    };
+    return completionDetails;
+  }
+}
+
+class LSPLogger {
+  constructor(info) {
+    this.info = info;
+  }
+  log(msg) {
+    this.info.project.projectService.logger.info(`[player-expr-lsp] ${msg}`);
+  }
+}
+
+module.exports = (mod) => {
+  return {
+    create(info) {
+      const logger = new LSPLogger(info);
+      const templateService = new ExpressionLanguageService({ logger });
+      return decorateWithTemplateLanguageService(mod.typescript, info.languageService, info.project, templateService, { tags: ["e", "expr"], enableForStringWithSubstitutions: true }, { logger });
+    }
+  };
+};
+//# sourceMappingURL=index.esm.js.map

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@player-tools/typescript-expression-plugin",
+  "version": "0.2.2--canary.20.454",
+  "private": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "peerDependencies": {},
+  "dependencies": {
+    "@player-ui/player": "0.3.1--canary.117.4130",
+    "typescript-template-language-service-decorator": "^2.3.1",
+    "@babel/runtime": "7.15.4"
+  },
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
+  "typings": "dist/index.d.ts",
+  "sideEffects": false,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/player-ui/tools"
+  },
+  "bugs": {
+    "url": "https://github.com/player-ui/tools/issues"
+  },
+  "homepage": "https://player-ui.github.io",
+  "contributors": [
+    {
+      "name": "Ketan Reddy",
+      "url": "https://github.com/KetanReddy"
+    }
+  ]
+}

package/src/index.ts

@@ -0,0 +1,23 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { decorateWithTemplateLanguageService } from 'typescript-template-language-service-decorator';
+import { ExpressionLanguageService } from './service';
+import { LSPLogger } from './logger';
+
+export = (mod: { typescript: typeof ts }) => {
+  return {
+    create(info: ts.server.PluginCreateInfo): ts.LanguageService {
+      const logger = new LSPLogger(info);
+
+      const templateService = new ExpressionLanguageService({ logger });
+
+      return decorateWithTemplateLanguageService(
+        mod.typescript,
+        info.languageService,
+        info.project,
+        templateService,
+        { tags: ['e', 'expr'], enableForStringWithSubstitutions: true },
+        { logger }
+      );
+    },
+  };
+};

package/src/logger.ts

@@ -0,0 +1,14 @@
+import type { Logger } from 'typescript-template-language-service-decorator';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+
+export class LSPLogger implements Logger {
+  private readonly info: ts.server.PluginCreateInfo;
+
+  constructor(info: ts.server.PluginCreateInfo) {
+    this.info = info;
+  }
+
+  log(msg: string) {
+    this.info.project.projectService.logger.info(`[player-expr-lsp] ${msg}`);
+  }
+}

package/src/service.ts

@@ -0,0 +1,188 @@
+import * as ts from 'typescript/lib/tsserverlibrary';
+import type {
+  TemplateLanguageService,
+  TemplateContext,
+  Logger,
+} from 'typescript-template-language-service-decorator';
+import { parseExpression } from '@player-ui/player';
+import { getTokenAtPosition } from './utils';
+
+// TODO: replace this with the XLR definitions and types
+interface ExprDetails {
+  name: string;
+  description: string;
+  args: Array<{
+    name: string;
+    type: string;
+  }>;
+}
+
+export class ExpressionLanguageService implements TemplateLanguageService {
+  private logger?: Logger;
+  private _expressions = new Map<string, ExprDetails>();
+
+  constructor(options?: { logger?: Logger }) {
+    this.logger = options?.logger;
+
+    this.setExpressions(
+      new Map([
+        [
+          'test',
+          {
+            name: 'test',
+            description: 'test expression',
+            args: [],
+          },
+        ],
+        [
+          'foo',
+          {
+            name: 'foo',
+            description: 'Test foo expression',
+            args: [
+              {
+                name: 'path',
+                type: 'string',
+              },
+            ],
+          },
+        ],
+      ])
+    );
+  }
+
+  setExpressions(expressionData: Map<string, ExprDetails>) {
+    this._expressions = expressionData;
+  }
+
+  getCompletionsAtPosition(
+    context: TemplateContext,
+    position: ts.LineAndCharacter
+  ): ts.CompletionInfo {
+    const line = context.text.split(/\n/g)[position.line];
+    this.logger?.log(
+      `[expression-LSP] getCompletionsAtPosition: ${line} -- ${context.rawText} -- ${context.text}`
+    );
+
+    const parsed = parseExpression(line, { strict: false });
+    const token = getTokenAtPosition(parsed, position);
+
+    const completionInfo: ts.CompletionInfo = {
+      isGlobalCompletion: false,
+      isMemberCompletion: false,
+      isNewIdentifierLocation: false,
+      entries: [],
+    };
+
+    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);
+      const allCompletions = Array.from(this._expressions.keys()).filter(
+        (key) => key.startsWith(wordFromStart)
+      );
+
+      allCompletions.forEach((c) => {
+        completionInfo.entries.push({
+          name: c,
+          kind: ts.ScriptElementKind.functionElement,
+          sortText: c,
+          isRecommended: true,
+        });
+      });
+    }
+
+    return completionInfo;
+  }
+
+  getQuickInfoAtPosition(
+    context: TemplateContext,
+    position: ts.LineAndCharacter
+  ): ts.QuickInfo | undefined {
+    this.logger?.log(`getCompletionsAtPosition: ${context.text}`);
+
+    const parsed = parseExpression(context.text, { strict: false });
+    const token = getTokenAtPosition(parsed, position);
+
+    if (token?.type === 'Identifier') {
+      const expression = this._expressions.get(token.name);
+      if (expression) {
+        return {
+          textSpan: {
+            start: token.location?.start.character ?? 0,
+            length: token.location?.end.character ?? 0,
+          },
+          kindModifiers: ts.ScriptElementKindModifier.none,
+          kind: ts.ScriptElementKind.functionElement,
+          documentation: [
+            {
+              kind: 'text',
+              text: expression.description,
+            },
+          ],
+        };
+      }
+    }
+
+    return undefined;
+  }
+
+  getCompletionEntryDetails(
+    context: TemplateContext,
+    position: ts.LineAndCharacter,
+    name: string
+  ): ts.CompletionEntryDetails {
+    const expression = this._expressions.get(name);
+
+    const prefix = [
+      {
+        text: ', ',
+        kind: ts.ScriptElementKind.unknown,
+      },
+    ];
+
+    const completionDetails: ts.CompletionEntryDetails = {
+      name,
+      kind: ts.ScriptElementKind.functionElement,
+      kindModifiers: ts.ScriptElementKindModifier.none,
+      documentation: [
+        {
+          kind: 'text',
+          text: expression?.description ?? 'Some description',
+        },
+      ],
+      displayParts: [
+        {
+          text: name,
+          kind: ts.ScriptElementKind.functionElement,
+        },
+        {
+          text: '(',
+          kind: ts.ScriptElementKind.unknown,
+        },
+
+        ...(expression?.args.flatMap((arg, index) => [
+          ...(index === 0 ? [] : prefix),
+          {
+            text: arg.name,
+            kind: ts.ScriptElementKind.parameterElement,
+          },
+          {
+            text: ': ',
+            kind: ts.ScriptElementKind.unknown,
+          },
+          {
+            text: arg.type,
+            kind: ts.ScriptElementKind.typeParameterElement,
+          },
+        ]) ?? []),
+        {
+          text: ')',
+          kind: ts.ScriptElementKind.unknown,
+        },
+      ],
+    };
+
+    return completionDetails;
+  }
+}

package/src/utils.ts

@@ -0,0 +1,45 @@
+import type { Position } from 'vscode-languageserver-types';
+import type { ExpressionNode, NodeLocation } from '@player-ui/player';
+
+/** Check if the vscode position overlaps with the expression location */
+export function isInRange(position: Position, location: NodeLocation) {
+  return (
+    position.character >= location.start.character &&
+    position.character <= location.end.character
+  );
+}
+
+/** Find the closest marked token at the given position */
+export function getTokenAtPosition(
+  node: ExpressionNode,
+  position: Position
+): ExpressionNode | undefined {
+  if (node.type === 'CallExpression') {
+    const anyArgs = node.args.find((arg) => {
+      return getTokenAtPosition(arg, position);
+    });
+
+    if (anyArgs) {
+      return anyArgs;
+    }
+
+    const asTarget = getTokenAtPosition(node.callTarget, position);
+    if (asTarget) {
+      return asTarget;
+    }
+  }
+
+  if (node.type === 'Assignment') {
+    const asTarget =
+      getTokenAtPosition(node.left, position) ??
+      getTokenAtPosition(node.right, position);
+    if (asTarget) {
+      return asTarget;
+    }
+  }
+
+  // Lastly check for yourself
+  if (node.location && isInRange(position, node.location)) {
+    return node;
+  }
+}

package/src/virtual-service-host.ts

@@ -0,0 +1,72 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+
+export default class VirtualServiceHost implements ts.LanguageServiceHost {
+  private readonly files = new Map<string, string>();
+  private readonly typescript: typeof ts;
+  private readonly compilerOptions: ts.CompilerOptions;
+  private readonly workspacePath: string;
+
+  constructor(
+    typescript: typeof ts,
+    compilerOptions: ts.CompilerOptions,
+    workspacePath: string
+  ) {
+    this.typescript = typescript;
+    this.compilerOptions = compilerOptions;
+    this.workspacePath = workspacePath;
+  }
+
+  withFile<T>(fileName: string, content: string, callback: () => T): T {
+    this.files.set(fileName, content);
+    const result = callback();
+    this.files.delete(fileName);
+    return result;
+  }
+
+  getCompilationSettings() {
+    return this.compilerOptions;
+  }
+
+  getScriptFileNames() {
+    return Array.from(this.files.keys());
+  }
+
+  getScriptKind() {
+    return this.typescript.ScriptKind.TS;
+  }
+
+  getScriptVersion() {
+    return '0';
+  }
+
+  getScriptSnapshot(fileName: string) {
+    const fileText = this.readFile(fileName);
+    if (fileText) {
+      return this.typescript.ScriptSnapshot.fromString(fileText);
+    }
+  }
+
+  getCurrentDirectory() {
+    return this.workspacePath;
+  }
+
+  getDefaultLibFileName(options: ts.CompilerOptions) {
+    return this.typescript.getDefaultLibFilePath(options);
+  }
+
+  fileExists(path: string): boolean {
+    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')
+      ? this.typescript.sys.readFile(path, encoding)
+      : this.files.get(path);
+  }
+
+  useCaseSensitiveFileNames() {
+    return true;
+  }
+}