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

package/README.md

@@ -0,0 +1,3 @@
+# @player-tools/json-language-server
+
+This package starts a node JSON-RPC server which maps LSP requests to the [@player-language/service](https://github.intuit.com/player/language/tree/master/packages/service). This is typically started by an IDE and used in conjunction with a client to receive the language features. 

package/dist/index.cjs.js

@@ -0,0 +1,207 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vscodeLanguageserver = require('vscode-languageserver');
+var vscodeLanguageserverTextdocument = require('vscode-languageserver-textdocument');
+var jsonLanguageService = require('@player-tools/json-language-service');
+var fs = require('fs');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+
+var __async$1 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function cancel() {
+  return new vscodeLanguageserver.ResponseError(-32800, "Request cancelled");
+}
+function runAndCatch(func, token, errorVal) {
+  return __async$1(this, null, function* () {
+    if (token.isCancellationRequested) {
+      return cancel();
+    }
+    try {
+      const result = yield func();
+      if (token.isCancellationRequested) {
+        return cancel();
+      }
+      return result;
+    } catch (e) {
+      return errorVal;
+    }
+  });
+}
+
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const dateFormat = new Intl.DateTimeFormat("en", {
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+  hour12: false,
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit"
+});
+const logFilePath = process.argv.length === 4 && fs__default["default"].existsSync(process.argv[3]) && process.argv[3];
+const formatLog = (a) => {
+  const msg = typeof a === "string" ? a : JSON.stringify(a);
+  const date = new Date();
+  return `${dateFormat.format(date)},$${date.getMilliseconds()} | ${msg} 
+`;
+};
+const fileLog = logFilePath ? (a) => fs__default["default"].appendFile(logFilePath, formatLog(a), () => {
+}) : () => {
+};
+const service = new jsonLanguageService.PlayerLanguageService();
+const connection = vscodeLanguageserver.createConnection(vscodeLanguageserver.ProposedFeatures.all);
+const documents = new vscodeLanguageserver.TextDocuments(vscodeLanguageserverTextdocument.TextDocument);
+let hasConfigurationCapability = false;
+process.on("unhandledRejection", (e) => {
+  console.error(e.message);
+});
+process.on("uncaughtException", (e) => {
+  console.error(e.message);
+});
+console.log = (a) => {
+  fileLog(a);
+  connection.console.log(JSON.stringify(a, null, 2));
+};
+console.error = (a) => {
+  fileLog(a);
+  connection.console.error(JSON.stringify(a, null, 2));
+};
+function validate(textDocument) {
+  return __async(this, null, function* () {
+    const diagnostics = yield service.validateTextDocument(textDocument);
+    if (diagnostics) {
+      connection.sendDiagnostics({ uri: textDocument.uri, diagnostics });
+    }
+  });
+}
+connection.onInitialize((params) => {
+  const { capabilities } = params;
+  hasConfigurationCapability = Boolean(capabilities.workspace && Boolean(capabilities.workspace.configuration));
+  fileLog("Initialized Player LSP Server");
+  return {
+    capabilities: {
+      textDocumentSync: vscodeLanguageserver.TextDocumentSyncKind.Full,
+      codeActionProvider: true,
+      definitionProvider: true,
+      completionProvider: {
+        resolveProvider: false,
+        triggerCharacters: ['"', ":"]
+      },
+      documentFormattingProvider: true,
+      documentRangeFormattingProvider: true,
+      hoverProvider: true
+    }
+  };
+});
+connection.onCompletion((textDocumentPosition, token) => __async(undefined, null, function* () {
+  return runAndCatch(() => {
+    const document = documents.get(textDocumentPosition.textDocument.uri);
+    if (document !== void 0) {
+      return service.getCompletionsAtPosition(document, textDocumentPosition.position);
+    }
+    return null;
+  }, token, null);
+}));
+connection.onHover((hoverParams, token) => __async(undefined, null, function* () {
+  return runAndCatch(() => {
+    const document = documents.get(hoverParams.textDocument.uri);
+    if (document !== void 0) {
+      return service.getHoverInfoAtPosition(document, hoverParams.position);
+    }
+    return null;
+  }, token, null);
+}));
+connection.onCompletionResolve((item, token) => runAndCatch(() => service.resolveCompletionItem(item), token, item));
+connection.onDocumentFormatting((formattingParams, token) => runAndCatch(() => {
+  const document = documents.get(formattingParams.textDocument.uri);
+  if (document !== void 0) {
+    return service.formatTextDocument(document, formattingParams.options);
+  }
+  return void 0;
+}, token, null));
+connection.onDocumentRangeFormatting((formattingParams, token) => runAndCatch(() => {
+  const document = documents.get(formattingParams.textDocument.uri);
+  if (document !== void 0) {
+    return service.formatTextDocument(document, formattingParams.options, formattingParams.range);
+  }
+  return void 0;
+}, token, null));
+connection.onDefinition((definitionParams, token) => runAndCatch(() => {
+  const document = documents.get(definitionParams.textDocument.uri);
+  if (document !== void 0) {
+    return service.getDefinitionAtPosition(document, definitionParams.position);
+  }
+  return void 0;
+}, token, null));
+connection.onInitialized(() => {
+  if (hasConfigurationCapability) {
+    connection.client.register(vscodeLanguageserver.DidChangeConfigurationNotification.type, void 0);
+  }
+});
+connection.onCodeAction((codeAction) => {
+  const document = documents.get(codeAction.textDocument.uri);
+  if (!document) {
+    return [];
+  }
+  return service.getCodeActionsInRange(document, codeAction.context);
+});
+documents.onDidClose((change) => {
+  service.onClose(change.document);
+});
+documents.onDidChangeContent((change) => {
+  validate(change.document);
+});
+connection.onNotification("player/setAssetBundles", (assetBundles) => {
+  if (Array.isArray(assetBundles)) {
+    console.log("Updating asset type bundles");
+    service.setAssetTypes(assetBundles);
+  }
+});
+fileLog("Starting Player LSP Server");
+documents.listen(connection);
+connection.listen();
+
+exports.runAndCatch = runAndCatch;
+//# sourceMappingURL=index.cjs.js.map

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { CancellationToken, ResponseError } from 'vscode-languageserver';
+
+/** Run the given function and handle being cancelled */
+declare function runAndCatch<T>(func: () => Promise<T> | T, token: CancellationToken, errorVal: T): Promise<T | ResponseError<any>>;
+
+export { runAndCatch };

package/dist/index.esm.js

@@ -0,0 +1,199 @@
+import { ResponseError, createConnection, ProposedFeatures, TextDocuments, TextDocumentSyncKind, DidChangeConfigurationNotification } from 'vscode-languageserver';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { PlayerLanguageService } from '@player-tools/json-language-service';
+import fs from 'fs';
+
+var __async$1 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function cancel() {
+  return new ResponseError(-32800, "Request cancelled");
+}
+function runAndCatch(func, token, errorVal) {
+  return __async$1(this, null, function* () {
+    if (token.isCancellationRequested) {
+      return cancel();
+    }
+    try {
+      const result = yield func();
+      if (token.isCancellationRequested) {
+        return cancel();
+      }
+      return result;
+    } catch (e) {
+      return errorVal;
+    }
+  });
+}
+
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const dateFormat = new Intl.DateTimeFormat("en", {
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+  hour12: false,
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit"
+});
+const logFilePath = process.argv.length === 4 && fs.existsSync(process.argv[3]) && process.argv[3];
+const formatLog = (a) => {
+  const msg = typeof a === "string" ? a : JSON.stringify(a);
+  const date = new Date();
+  return `${dateFormat.format(date)},$${date.getMilliseconds()} | ${msg} 
+`;
+};
+const fileLog = logFilePath ? (a) => fs.appendFile(logFilePath, formatLog(a), () => {
+}) : () => {
+};
+const service = new PlayerLanguageService();
+const connection = createConnection(ProposedFeatures.all);
+const documents = new TextDocuments(TextDocument);
+let hasConfigurationCapability = false;
+process.on("unhandledRejection", (e) => {
+  console.error(e.message);
+});
+process.on("uncaughtException", (e) => {
+  console.error(e.message);
+});
+console.log = (a) => {
+  fileLog(a);
+  connection.console.log(JSON.stringify(a, null, 2));
+};
+console.error = (a) => {
+  fileLog(a);
+  connection.console.error(JSON.stringify(a, null, 2));
+};
+function validate(textDocument) {
+  return __async(this, null, function* () {
+    const diagnostics = yield service.validateTextDocument(textDocument);
+    if (diagnostics) {
+      connection.sendDiagnostics({ uri: textDocument.uri, diagnostics });
+    }
+  });
+}
+connection.onInitialize((params) => {
+  const { capabilities } = params;
+  hasConfigurationCapability = Boolean(capabilities.workspace && Boolean(capabilities.workspace.configuration));
+  fileLog("Initialized Player LSP Server");
+  return {
+    capabilities: {
+      textDocumentSync: TextDocumentSyncKind.Full,
+      codeActionProvider: true,
+      definitionProvider: true,
+      completionProvider: {
+        resolveProvider: false,
+        triggerCharacters: ['"', ":"]
+      },
+      documentFormattingProvider: true,
+      documentRangeFormattingProvider: true,
+      hoverProvider: true
+    }
+  };
+});
+connection.onCompletion((textDocumentPosition, token) => __async(undefined, null, function* () {
+  return runAndCatch(() => {
+    const document = documents.get(textDocumentPosition.textDocument.uri);
+    if (document !== void 0) {
+      return service.getCompletionsAtPosition(document, textDocumentPosition.position);
+    }
+    return null;
+  }, token, null);
+}));
+connection.onHover((hoverParams, token) => __async(undefined, null, function* () {
+  return runAndCatch(() => {
+    const document = documents.get(hoverParams.textDocument.uri);
+    if (document !== void 0) {
+      return service.getHoverInfoAtPosition(document, hoverParams.position);
+    }
+    return null;
+  }, token, null);
+}));
+connection.onCompletionResolve((item, token) => runAndCatch(() => service.resolveCompletionItem(item), token, item));
+connection.onDocumentFormatting((formattingParams, token) => runAndCatch(() => {
+  const document = documents.get(formattingParams.textDocument.uri);
+  if (document !== void 0) {
+    return service.formatTextDocument(document, formattingParams.options);
+  }
+  return void 0;
+}, token, null));
+connection.onDocumentRangeFormatting((formattingParams, token) => runAndCatch(() => {
+  const document = documents.get(formattingParams.textDocument.uri);
+  if (document !== void 0) {
+    return service.formatTextDocument(document, formattingParams.options, formattingParams.range);
+  }
+  return void 0;
+}, token, null));
+connection.onDefinition((definitionParams, token) => runAndCatch(() => {
+  const document = documents.get(definitionParams.textDocument.uri);
+  if (document !== void 0) {
+    return service.getDefinitionAtPosition(document, definitionParams.position);
+  }
+  return void 0;
+}, token, null));
+connection.onInitialized(() => {
+  if (hasConfigurationCapability) {
+    connection.client.register(DidChangeConfigurationNotification.type, void 0);
+  }
+});
+connection.onCodeAction((codeAction) => {
+  const document = documents.get(codeAction.textDocument.uri);
+  if (!document) {
+    return [];
+  }
+  return service.getCodeActionsInRange(document, codeAction.context);
+});
+documents.onDidClose((change) => {
+  service.onClose(change.document);
+});
+documents.onDidChangeContent((change) => {
+  validate(change.document);
+});
+connection.onNotification("player/setAssetBundles", (assetBundles) => {
+  if (Array.isArray(assetBundles)) {
+    console.log("Updating asset type bundles");
+    service.setAssetTypes(assetBundles);
+  }
+});
+fileLog("Starting Player LSP Server");
+documents.listen(connection);
+connection.listen();
+
+export { runAndCatch };
+//# sourceMappingURL=index.esm.js.map

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@player-tools/json-language-server",
+  "version": "0.2.2--canary.20.454",
+  "private": false,
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "peerDependencies": {},
+  "dependencies": {
+    "@player-tools/json-language-service": "0.2.2--canary.20.454",
+    "vscode-languageserver": "^6.1.1",
+    "vscode-languageserver-textdocument": "^1.0.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,240 @@
+/* eslint-disable no-console */
+import type { InitializeParams } from 'vscode-languageserver';
+import {
+  createConnection,
+  ProposedFeatures,
+  TextDocuments,
+  DidChangeConfigurationNotification,
+  TextDocumentSyncKind,
+} from 'vscode-languageserver';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { PlayerLanguageService } from '@player-tools/json-language-service';
+import fs from 'fs';
+import { runAndCatch } from './utils';
+
+export * from './utils';
+
+const dateFormat = new Intl.DateTimeFormat('en', {
+  year: 'numeric',
+  month: '2-digit',
+  day: '2-digit',
+  hour12: false,
+  hour: '2-digit',
+  minute: '2-digit',
+  second: '2-digit',
+});
+
+const logFilePath =
+  process.argv.length === 4 &&
+  fs.existsSync(process.argv[3]) &&
+  process.argv[3];
+
+/** Format a log message to work in the console */
+const formatLog = (a: unknown): string => {
+  const msg = typeof a === 'string' ? a : JSON.stringify(a);
+  const date = new Date();
+  return `${dateFormat.format(date)},$${date.getMilliseconds()} | ${msg} \n`;
+};
+
+const fileLog = logFilePath
+  ? (a: unknown) =>
+      fs.appendFile(logFilePath, formatLog(a), () => {
+        /* do nothing */
+      })
+  : () => {
+      /* do nothing */
+    };
+
+const service = new PlayerLanguageService();
+
+const connection = createConnection(ProposedFeatures.all);
+const documents = new TextDocuments(TextDocument);
+
+let hasConfigurationCapability = false;
+
+process.on('unhandledRejection', (e: Error) => {
+  console.error(e.message);
+});
+process.on('uncaughtException', (e: Error) => {
+  console.error(e.message);
+});
+
+console.log = (a: Error) => {
+  fileLog(a);
+  connection.console.log(JSON.stringify(a, null, 2));
+};
+
+console.error = (a: Error) => {
+  fileLog(a);
+  connection.console.error(JSON.stringify(a, null, 2));
+};
+
+/** Handle validating a text-document and returning the response back to the extension */
+async function validate(textDocument: TextDocument): Promise<void> {
+  const diagnostics = await service.validateTextDocument(textDocument);
+
+  if (diagnostics) {
+    connection.sendDiagnostics({ uri: textDocument.uri, diagnostics });
+  }
+}
+
+connection.onInitialize((params: InitializeParams) => {
+  const { capabilities } = params;
+
+  // Does the client support the `workspace/configuration` request?
+  // If not, we will fall back using global settings
+  hasConfigurationCapability = Boolean(
+    capabilities.workspace && Boolean(capabilities.workspace.configuration)
+  );
+
+  fileLog('Initialized Player LSP Server');
+  return {
+    capabilities: {
+      textDocumentSync: TextDocumentSyncKind.Full,
+      codeActionProvider: true,
+      definitionProvider: true,
+      completionProvider: {
+        resolveProvider: false,
+        triggerCharacters: ['"', ':'],
+      },
+      documentFormattingProvider: true,
+      documentRangeFormattingProvider: true,
+      hoverProvider: true,
+    },
+  };
+});
+
+connection.onCompletion(async (textDocumentPosition, token) => {
+  return runAndCatch(
+    () => {
+      const document = documents.get(textDocumentPosition.textDocument.uri);
+      if (document !== undefined) {
+        return service.getCompletionsAtPosition(
+          document,
+          textDocumentPosition.position
+        );
+      }
+
+      return null;
+    },
+    token,
+    null
+  );
+});
+
+connection.onHover(async (hoverParams, token) => {
+  return runAndCatch(
+    () => {
+      const document = documents.get(hoverParams.textDocument.uri);
+      if (document !== undefined) {
+        return service.getHoverInfoAtPosition(document, hoverParams.position);
+      }
+
+      return null;
+    },
+    token,
+    null
+  );
+});
+
+connection.onCompletionResolve((item, token) =>
+  runAndCatch(() => service.resolveCompletionItem(item), token, item)
+);
+
+connection.onDocumentFormatting((formattingParams, token) =>
+  runAndCatch(
+    () => {
+      const document = documents.get(formattingParams.textDocument.uri);
+
+      if (document !== undefined) {
+        return service.formatTextDocument(document, formattingParams.options);
+      }
+
+      return undefined;
+    },
+    token,
+    null
+  )
+);
+
+connection.onDocumentRangeFormatting((formattingParams, token) =>
+  runAndCatch(
+    () => {
+      const document = documents.get(formattingParams.textDocument.uri);
+
+      if (document !== undefined) {
+        return service.formatTextDocument(
+          document,
+          formattingParams.options,
+          formattingParams.range
+        );
+      }
+
+      return undefined;
+    },
+    token,
+    null
+  )
+);
+
+connection.onDefinition((definitionParams, token) =>
+  runAndCatch(
+    () => {
+      const document = documents.get(definitionParams.textDocument.uri);
+
+      if (document !== undefined) {
+        return service.getDefinitionAtPosition(
+          document,
+          definitionParams.position
+        );
+      }
+
+      return undefined;
+    },
+    token,
+    null
+  )
+);
+
+connection.onInitialized(() => {
+  if (hasConfigurationCapability) {
+    // Register for all configuration changes.
+    connection.client.register(
+      DidChangeConfigurationNotification.type,
+      undefined
+    );
+  }
+});
+
+connection.onCodeAction((codeAction) => {
+  const document = documents.get(codeAction.textDocument.uri);
+  if (!document) {
+    return [];
+  }
+
+  return service.getCodeActionsInRange(document, codeAction.context);
+});
+
+documents.onDidClose((change) => {
+  service.onClose(change.document);
+});
+
+documents.onDidChangeContent((change) => {
+  validate(change.document);
+});
+
+connection.onNotification(
+  'player/setAssetBundles',
+  (assetBundles: Array<string>) => {
+    // Don't trust data over the wire
+    if (Array.isArray(assetBundles)) {
+      console.log('Updating asset type bundles');
+      service.setAssetTypes(assetBundles);
+    }
+  }
+);
+
+fileLog('Starting Player LSP Server');
+
+documents.listen(connection);
+connection.listen();

package/src/utils.ts

@@ -0,0 +1,32 @@
+import type { CancellationToken } from 'vscode-languageserver';
+import { ResponseError } from 'vscode-languageserver';
+
+/** Get a cancellation error   */
+function cancel() {
+  return new ResponseError(
+    -32800 /* ErrorCodes.RequestCancelled */,
+    'Request cancelled'
+  );
+}
+
+/** Run the given function and handle being cancelled */
+export async function runAndCatch<T>(
+  func: () => Promise<T> | T,
+  token: CancellationToken,
+  errorVal: T
+): Promise<T | ResponseError<any>> {
+  if (token.isCancellationRequested) {
+    return cancel();
+  }
+
+  try {
+    const result = await func();
+    if (token.isCancellationRequested) {
+      return cancel();
+    }
+
+    return result;
+  } catch (e) {
+    return errorVal;
+  }
+}